fuli-context 0.7.10-beta.7 → 0.8.0

package/graph-provider/fuli_graph/project_agent_coordination_models.py

@@ -1,6 +1,6 @@
 from datetime import datetime
 
-from pydantic import Field
+from pydantic import Field, field_validator, model_validator
 
 from .models import StrictModel
 
@@ -12,6 +12,9 @@ class ProjectAgentCoordinationPolicyRecord(StrictModel):
     personal_project_id: str
     ask_before_recruitment: bool = True
     auto_reuse_previous_agent: bool = True
+    auto_grow_team: bool = True
+    team_lead_agent_id: str | None = None
+    team_member_agent_ids: list[str] = Field(default_factory=list)
     updated_at: datetime | None = None
 
 
@@ -20,3 +23,22 @@ class ProjectAgentCoordinationPolicyUpdate(StrictModel):
     personal_project_id: str = Field(min_length=1, max_length=128)
     ask_before_recruitment: bool = True
     auto_reuse_previous_agent: bool = True
+    auto_grow_team: bool | None = None
+    team_lead_agent_id: str | None = Field(default=None, min_length=1, max_length=128)
+    team_member_agent_ids: list[str] = Field(default_factory=list, max_length=32)
+    expected_updated_at: datetime | None = None
+
+    @field_validator('team_member_agent_ids')
+    @classmethod
+    def validate_members(cls, value):
+        if any(not item.strip() or len(item) > 128 for item in value):
+            raise ValueError('team member IDs must contain 1 to 128 characters')
+        if len(set(value)) != len(value):
+            raise ValueError('team member IDs must be unique')
+        return value
+
+    @model_validator(mode='after')
+    def validate_team(self):
+        if self.team_lead_agent_id in self.team_member_agent_ids:
+            raise ValueError('the team lead cannot also be a team member')
+        return self

package/graph-provider/fuli_graph/project_agent_memory_models.py

@@ -65,6 +65,16 @@ class ProjectAgentMemoryRecord(StrictModel):
     created_at: datetime
 
 
+class EmployeeWorkLogRecord(StrictModel):
+    task_context_token: str
+    source_application: SourceApplication
+    session_id: str
+    created_at: datetime
+    status: Literal['reported', 'completed', 'incomplete', 'failed', 'no_change', 'unreported', 'running']
+    summary: str = Field(min_length=1, max_length=2000)
+    memory_updated: bool
+
+
 class ProjectAgentMemoryView(StrictModel):
     personal_space_id: str
     personal_project_id: str
@@ -77,3 +87,4 @@ class ProjectAgentMemoryView(StrictModel):
     revision: int = Field(default=0, ge=0)
     current: ProjectAgentMemoryRecord | None = None
     history: list[ProjectAgentMemoryRecord] = Field(default_factory=list)
+    work_log: list[EmployeeWorkLogRecord] = Field(default_factory=list, max_length=6)

package/graph-provider/fuli_graph/project_agent_team_growth.py

@@ -0,0 +1,56 @@
+"""Grow a project team inside the recruitment transaction, without changing authority."""
+
+from fastapi import HTTPException
+
+from .provider_values import now_utc
+
+
+async def enroll_recruited_team_member(store, recruitment, profile):
+    # Temporary workers and system employees do not become permanent teammates.
+    if (profile.agent_type != 'durable' or profile.status != 'active'
+            or any(cap.startswith('fuli.employee:') for cap in profile.capabilities)):
+        return
+    space_id = recruitment['personal_space_id']
+    project_id = recruitment['personal_project_id']
+    rows, _, _ = await store.runtime.driver.execute_query(
+        '''
+        MATCH (:FuliSpace {id: $space_id})-[:CONTAINS_PROJECT]->
+              (project:FuliPersonalProject {project_id: $project_id})
+        MATCH (project)-[:HAS_PROJECT_AGENT_ASSIGNMENT]->
+              (:FuliProjectAgentAssignment {status: 'active'})-[:ASSIGNED_AGENT]->
+              (agent:FuliProjectAgent {agent_id: $agent_id, status: 'active'})
+        WITH DISTINCT project, agent
+        MERGE (policy:FuliProjectAgentCoordinationPolicy {policy_id: $policy_id})
+        ON CREATE SET policy.personal_space_id = $space_id,
+                      policy.personal_project_id = $project_id,
+                      policy.created_at = $updated_at
+        SET policy._fuli_write_lock = true
+        REMOVE policy._fuli_write_lock
+        MERGE (project)-[:HAS_PROJECT_AGENT_COORDINATION_POLICY]->(policy)
+        WITH policy, agent, coalesce(policy.auto_grow_team, true) AS enabled,
+             coalesce(policy.team_member_agent_ids, []) AS members
+        WITH policy, agent, members, enabled,
+             policy.team_lead_agent_id IS NULL AS needs_lead,
+             coalesce(policy.team_lead_agent_id = agent.agent_id, false)
+               OR agent.agent_id IN members AS already_member
+        WITH *, enabled AND NOT already_member
+                  AND (needs_lead OR size(members) < 32) AS changed
+        FOREACH (_ IN CASE WHEN changed THEN [1] ELSE [] END |
+          SET policy.team_lead_agent_id = CASE WHEN needs_lead
+                THEN agent.agent_id ELSE policy.team_lead_agent_id END,
+              policy.team_member_agent_ids = CASE WHEN needs_lead
+                THEN members ELSE members + agent.agent_id END,
+              policy.updated_at = $updated_at
+        )
+        RETURN enabled AND NOT already_member AND NOT needs_lead
+                 AND size(members) >= 32 AS full
+        ''',
+        space_id=space_id, project_id=project_id,
+        agent_id=recruitment['proposed_agent_id'],
+        policy_id=store._project_agent_coordination_policy_id(space_id, project_id),
+        updated_at=now_utc(),
+    )
+    if not rows:
+        raise HTTPException(409, 'recruited Agent has no active project assignment')
+    if rows[0]['full']:
+        raise HTTPException(409, 'project team is full; change the team before recruiting')

package/graph-provider/fuli_graph/project_agent_work_log.py

@@ -0,0 +1,34 @@
+"""Recover bounded employee work records independently of distilled memory updates."""
+
+import json
+
+
+async def read_employee_work_log(store, space_id, project_id, agent_id):
+    rows, _, _ = await store.runtime.driver.execute_query(
+        '''
+        MATCH (:FuliSpace {id: $space_id})-[:HAS_TASK_CONTEXT_SESSION]->
+              (session:FuliTaskContextSession)-[:HAS_CONTEXT]->(task:FuliTaskContext)
+        WHERE task.personal_project_id = $project_id AND task.project_agent_id = $agent_id
+        RETURN task.record_json AS record_json, task.completed AS completed,
+               task.agent_memory_claimed AS memory_updated,
+               task.token = session.current_token AS current
+        ORDER BY task.created_at DESC, task.token LIMIT 6
+        ''', space_id=space_id, project_id=project_id, agent_id=agent_id, routing_='r',
+    )
+    result = []
+    for row in rows:
+        record = json.loads(row['record_json'])
+        checkpoint = record.get('checkpoint') or {}
+        log = checkpoint.get('work_log') or {}
+        result.append({
+            'task_context_token': record['token'],
+            'source_application': record['source_application'],
+            'session_id': record['session_id'],
+            'created_at': record['created_at'],
+            'status': (log.get('status', 'unreported') if row['completed']
+                       else 'running' if row.get('current') else 'incomplete'),
+            'summary': log.get('summary') or checkpoint.get('reason')
+                or 'The employee has not submitted a work summary for this task.',
+            'memory_updated': bool(row.get('memory_updated')),
+        })
+    return result

package/graph-provider/fuli_graph/store_project_agent_coordination_policy.py

@@ -1,5 +1,7 @@
 """Project-local Agent continuity and recruitment authorization."""
 
+from fastapi import HTTPException
+
 from .personal_project_access import authorize_personal_project
 from .project_agent_coordination_models import (
     ProjectAgentCoordinationPolicyRecord,
@@ -9,7 +11,7 @@ from .provider_values import native_datetime, now_utc, stable_uuid
 
 
 class StoreProjectAgentCoordinationPolicy:
-    """Persist the two user-facing project Agent automation switches."""
+    """Persist project automation and a stable team without absorbing peer roles."""
 
     async def get_project_agent_coordination_policy(
         self,
@@ -53,6 +55,9 @@ class StoreProjectAgentCoordinationPolicy:
                 'auto_reuse_previous_agent',
                 True,
             ),
+            team_lead_agent_id=raw.get('team_lead_agent_id'),
+            auto_grow_team=raw.get('auto_grow_team', True),
+            team_member_agent_ids=raw.get('team_member_agent_ids') or [],
             updated_at=native_datetime(raw.get('updated_at')),
         )
 
@@ -77,8 +82,38 @@ class StoreProjectAgentCoordinationPolicy:
             request.personal_space_id,
             request.personal_project_id,
         )
+        current = await self.get_project_agent_coordination_policy(
+            actor, request.personal_space_id, request.personal_project_id,
+        )
+        if ('expected_updated_at' in request.model_fields_set
+                and request.expected_updated_at != current.updated_at):
+            raise HTTPException(status_code=409, detail='coordination policy changed; reload before saving')
+        lead = (request.team_lead_agent_id if 'team_lead_agent_id' in request.model_fields_set
+                else current.team_lead_agent_id)
+        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 members and not lead:
+            raise HTTPException(status_code=422, detail='select a team lead before adding members')
+        if lead in members:
+            raise HTTPException(status_code=422, detail='the team lead cannot also be a team member')
+        if 'team_lead_agent_id' in request.model_fields_set or 'team_member_agent_ids' in request.model_fields_set:
+            for agent_id in ([lead] if lead else []) + members:
+                agent = await self.get_project_agent(
+                    actor, request.personal_space_id, request.personal_project_id, agent_id,
+                )
+                profile = agent.profile
+                active_assignment = any(
+                    assignment.status == 'active'
+                    and assignment.personal_project_id == request.personal_project_id
+                    for assignment in agent.assignments
+                )
+                if (profile.status != 'active' or not active_assignment
+                        or profile.agent_type != 'durable'
+                        or any(cap.startswith('fuli.employee:') for cap in profile.capabilities)):
+                    raise HTTPException(status_code=422, detail='team roles require active durable project assignments; HR and project managers remain peers')
         updated_at = now_utc()
-        await self.runtime.driver.execute_query(
+        written, _, _ = await self.runtime.driver.execute_query(
             '''
             MATCH (:FuliSpace {id: $personal_space_id, kind: 'personal'})-
                   [:CONTAINS_PROJECT]->
@@ -89,23 +124,42 @@ class StoreProjectAgentCoordinationPolicy:
             ON CREATE SET policy.personal_space_id = $personal_space_id,
                           policy.personal_project_id = $personal_project_id,
                           policy.created_at = $updated_at
+            SET policy._fuli_write_lock = true
+            REMOVE policy._fuli_write_lock
+            WITH project, policy
+            WHERE ($expected_updated_at IS NULL AND policy.updated_at IS NULL)
+               OR (policy.updated_at.epochSeconds = $expected_updated_at.epochSeconds
+                   AND policy.updated_at.nanosecond = $expected_updated_at.nanosecond)
             SET policy.ask_before_recruitment = $ask_before_recruitment,
                 policy.auto_reuse_previous_agent = $auto_reuse_previous_agent,
+                policy.auto_grow_team = $auto_grow_team,
+                policy.team_lead_agent_id = $team_lead_agent_id,
+                policy.team_member_agent_ids = $team_member_agent_ids,
                 policy.updated_at = $updated_at
             MERGE (project)-[:HAS_PROJECT_AGENT_COORDINATION_POLICY]->(policy)
+            RETURN policy
             ''',
             policy_id=policy_id,
             personal_space_id=request.personal_space_id,
             personal_project_id=request.personal_project_id,
             ask_before_recruitment=request.ask_before_recruitment,
             auto_reuse_previous_agent=request.auto_reuse_previous_agent,
+            auto_grow_team=auto_grow,
+            team_lead_agent_id=lead,
+            team_member_agent_ids=members,
+            expected_updated_at=current.updated_at,
             updated_at=updated_at,
         )
+        if not written:
+            raise HTTPException(status_code=409, detail='coordination policy changed; reload before saving')
         return ProjectAgentCoordinationPolicyRecord(
             personal_space_id=request.personal_space_id,
             personal_project_id=request.personal_project_id,
             ask_before_recruitment=request.ask_before_recruitment,
             auto_reuse_previous_agent=request.auto_reuse_previous_agent,
+            auto_grow_team=auto_grow,
+            team_lead_agent_id=lead,
+            team_member_agent_ids=members,
             updated_at=updated_at,
         )
 

package/graph-provider/fuli_graph/store_project_agent_memory.py

@@ -16,6 +16,7 @@ from .project_agent_memory_models import (
     ProjectAgentMemoryWrite,
 )
 from .provider_values import now_utc, stable_uuid
+from .project_agent_work_log import read_employee_work_log
 from .system_hr_identity import LEGACY_HR_AGENT_ID, SYSTEM_HR_AGENT_ID, resolve_hr_alias
 
 
@@ -53,6 +54,8 @@ class StoreProjectAgentMemory:
             revision=current.revision if current else 0,
             current=current,
             history=history,
+            work_log=await read_employee_work_log(self, personal_space_id,
+                                                  personal_project_id, agent['agent_id']),
         )
 
     async def write_project_agent_memory(

package/graph-provider/fuli_graph/store_project_agent_task_activity.py

@@ -266,7 +266,7 @@ class StoreProjectAgentTaskActivity:
               THEN [1] ELSE [] END |
               SET task.status = $status,
                   task.result_summary = CASE
-                    WHEN $status = 'completed' THEN $summary
+                    WHEN $status IN ['completed', 'awaiting_review', 'failed', 'blocked', 'cancelled'] THEN $summary
                     ELSE task.result_summary END,
                   task.failure_reason = CASE
                     WHEN $status = 'failed' THEN $summary

package/graph-provider/fuli_graph/store_project_agent_task_recruitment.py

@@ -26,6 +26,7 @@ from .project_agent_task_models import (
 from .provider_values import native_datetime, now_utc, stable_uuid
 from .store_project_agents import SYSTEM_HR_AGENT_ID
 from .store_transactions import query_store_transaction
+from .project_agent_team_growth import enroll_recruited_team_member
 
 
 RECRUITMENT_CLAIM_TTL = timedelta(minutes=2)
@@ -1236,6 +1237,7 @@ class StoreProjectAgentTaskRecruitment:
             include_temporary=True,
         )
         selected = next(item for item in assignment_rows if item['agent_id'] == agent_id)
+        await enroll_recruited_team_member(self, raw, profile)
         return selected
 
     async def _get_recruitment(self, personal_space_id, recruitment_id):

package/graph-provider/fuli_graph/store_project_agent_task_staffing.py

@@ -62,6 +62,18 @@ class StoreProjectAgentTaskStaffing:
             return [], rows, 'manual_agent_selection', [
                 'project policy requires an explicit @Agent selection',
             ]
+        team_lead = getattr(policy, 'team_lead_agent_id', None)
+        if team_lead:
+            lead = next((row for row in rows if row['agent_id'] == team_lead), None)
+            if lead is None:
+                return [], rows, 'agent_unavailable', ['configured team lead is unavailable; select or replace the lead']
+            member_ids = set(getattr(policy, 'team_member_agent_ids', []))
+            members = [row for row in rows if row['agent_id'] in member_ids]
+            return [lead], [lead, *members], 'project_team_lead', [
+                'project team lead is the stable conversation owner',
+                f'{len(members)} active team member(s) available for explicit workstreams',
+                'HR and project manager remain peer roles',
+            ]
         normalized_work_kind = request.work_kind.casefold()
         required = {item.casefold() for item in request.required_capabilities}
         eligible = [row for row in rows if required.issubset({
@@ -506,16 +518,19 @@ class StoreProjectAgentTaskStaffing:
         request,
         candidates,
         participants,
+        *,
+        team_only=False,
     ):
         capacity = len(request.parallel_plan.workstream_boundaries) - len(participants)
         if capacity <= 0:
             return []
         pool = list(candidates)
         known_ids = {item['agent_id'] for item in pool}
-        for row in await self._assignment_candidates(
+        assignments = [] if team_only else await self._assignment_candidates(
             request.personal_space_id,
             request.personal_project_id,
-        ):
+        )
+        for row in assignments:
             if row['agent_id'] not in known_ids:
                 pool.append(row)
                 known_ids.add(row['agent_id'])

package/graph-provider/fuli_graph/store_project_agent_tasks.py

@@ -147,6 +147,7 @@ class StoreProjectAgentTasks(
                 request,
                 candidates,
                 participants,
+                **({'team_only': True} if reason == 'project_team_lead' else {}),
             )
             candidate_ids = {item['agent_id'] for item in candidates}
             candidates.extend(

package/graph-provider/fuli_graph/store_task_contexts.py

@@ -14,9 +14,13 @@ from .project_agent_access import authorize_project_agent
 from .provider_values import now_utc, stable_uuid
 from .project_agent_memory_models import ProjectAgentMemoryWrite
 from .store_transactions import query_store_transaction
+from .task_context_adoption import adopt_task_agent
 
 
 class StoreTaskContexts:
+    async def adopt_task_context_agent(self, actor, token, request):
+        return await adopt_task_agent(self, actor, token, request)
+
     async def begin_task_context(self, actor, request):
         self._require_personal()
         space = await self.authorize(actor, request.personal_space_id, 'maintainer')
@@ -133,6 +137,8 @@ class StoreTaskContexts:
         record = await self.get_task_context(
             actor, request.personal_space_id, token, request.source_application,
         )
+        if record.get('work_log_required') and request.work_log is None:
+            raise HTTPException(422, 'Employee work summary is required before checkpointing')
         checkpoint = request.model_dump(mode='json', exclude={
             'personal_space_id', 'source_application', 'agent_memory',
         })
@@ -163,12 +169,14 @@ class StoreTaskContexts:
             WITH task, first_claim OR (
               task.fingerprint = $fingerprint AND task.disposition = $disposition
               AND task.reason = $reason
+              AND coalesce(task.work_log_json, 'null') = $work_log_json
               AND (NOT $is_prepare OR memory_claimed = $has_agent_memory)
             ) AS matches,
             CASE WHEN first_claim THEN $has_agent_memory ELSE memory_claimed END AS memory_claimed
             FOREACH (ignored IN CASE WHEN matches AND NOT task.completed THEN [1] ELSE [] END |
               SET task.fingerprint = $fingerprint, task.record_json = $record_json,
                   task.agent_memory_claimed = memory_claimed,
+                  task.work_log_json = $work_log_json,
                   task.completed = $completed, task.disposition = $disposition, task.reason = $reason
             )
             RETURN matches, task.record_json AS record_json
@@ -178,6 +186,8 @@ class StoreTaskContexts:
             completed=request.phase == 'complete',
             is_prepare=request.phase == 'prepare',
             has_agent_memory=request.agent_memory is not None,
+            work_log_json=json.dumps(request.work_log.model_dump() if request.work_log else None,
+                                     sort_keys=True, ensure_ascii=False),
             memory_checkpoint_id=memory_checkpoint_id,
         )
         if not rows or not rows[0]['matches']:
@@ -208,7 +218,7 @@ class StoreTaskContexts:
             'task_context_token': record['token'],
             'reason': f'FULI_CHECKPOINT_REQUIRED: {record["token"]} '
                 'Before finishing, call checkpoint_task_knowledge using this task_context_token '
-                'with capture_candidates or retain_nothing; include agentMemory when durable '
+                'with capture_candidates or retain_nothing and workLog (summary and truthful status); include agentMemory when durable '
                 'role context changed. Never store raw transcripts or credentials.',
         }
 

package/graph-provider/fuli_graph/task_context_adoption.py

@@ -0,0 +1,65 @@
+"""Claim an initially unassigned task after recruitment, never replace an owner."""
+
+import json
+
+from fastapi import HTTPException
+from .project_agent_access import authorize_project_agent
+
+
+async def adopt_task_agent(store, actor, token, request):
+    space = await store.authorize(actor, request.personal_space_id, 'maintainer')
+    record = await store.get_task_context(actor, request.personal_space_id, token,
+                                          request.source_application)
+    if record['personal_project_id'] != request.personal_project_id:
+        raise HTTPException(409, 'Task context belongs to another project')
+    if record.get('project_agent_id'):
+        if record['project_agent_id'] == request.agent_id:
+            return record
+        raise HTTPException(409, 'Task context already has an employee')
+    before = json.dumps(record, ensure_ascii=False)
+    agent = await authorize_project_agent(store, actor, space, request.personal_project_id,
+                                          request.agent_id, require_active=True, require_memory=True)
+    if request.source_application not in json.loads(agent['profile_json']).get('allowed_clients', []):
+        raise HTTPException(403, 'Agent is not allowed in this client')
+    memory = await store.get_project_agent_memory(actor, request.personal_space_id,
+                                                  request.personal_project_id, request.agent_id)
+    record.update(project_agent_id=request.agent_id, memory_revision=memory.revision,
+                  work_log_required=True)
+    rows, _, _ = await store.runtime.driver.execute_query(
+        '''
+        MATCH (space:FuliSpace {id: $space_id})-[:HAS_TASK_CONTEXT_SESSION]->
+              (session:FuliTaskContextSession)-[:HAS_CONTEXT]->(context:FuliTaskContext {token: $token})
+        MATCH (space)-[:HAS_PROJECT_AGENT_TASK]->(task:FuliProjectAgentTask {
+          task_id: $task_id, personal_project_id: $project_id, lead_agent_id: $agent_id})
+        SET session.write_serial = coalesce(session.write_serial, 0) + 1
+        WITH context, session, task
+        SET task._task_lifecycle_lock = true
+        REMOVE task._task_lifecycle_lock
+        WITH context, session, task
+        MATCH (task)-[:HAS_PARTICIPANT]->(agent:FuliProjectAgent {agent_id: $agent_id, status: 'active'})
+        SET agent._task_lifecycle_lock = true
+        REMOVE agent._task_lifecycle_lock
+        WITH context, session, agent, task
+        WHERE context.token = session.current_token AND context.project_agent_id IS NULL
+          AND context.fingerprint IS NULL AND NOT context.completed
+          AND context.record_json = $before
+          AND agent.profile_json = $profile_json
+          AND task.status IN ['queued', 'running', 'paused', 'blocked', 'awaiting_recruitment']
+          AND EXISTS {
+            MATCH (:FuliSpace {id: $space_id})-[:CONTAINS_PROJECT]->
+              (:FuliPersonalProject {project_id: $project_id})-[:HAS_PROJECT_AGENT_ASSIGNMENT]->
+              (:FuliProjectAgentAssignment {status: 'active'})-[:ASSIGNED_AGENT]->(agent)
+          }
+        SET context.project_agent_id = agent.agent_id, context.record_json = $record_json
+        RETURN context.record_json AS record_json
+        ''', space_id=request.personal_space_id, project_id=request.personal_project_id,
+        task_id=request.task_id, agent_id=request.agent_id, token=token,
+        before=before, record_json=json.dumps(record, ensure_ascii=False), profile_json=agent['profile_json'],
+    )
+    if not rows:
+        latest = await store.get_task_context(actor, request.personal_space_id, token,
+                                              request.source_application)
+        if latest.get('project_agent_id') == request.agent_id:
+            return latest
+        raise HTTPException(409, 'Task employee claim changed, completed, or is not the routed lead')
+    return json.loads(rows[0]['record_json'])

package/graph-provider/fuli_graph/task_context_models.py

@@ -2,7 +2,7 @@
 
 from typing import Literal
 
-from pydantic import Field, model_validator
+from pydantic import Field, field_validator, model_validator
 
 from .models import SourceApplication, StrictModel
 from .model_validation import reject_credentials
@@ -19,6 +19,7 @@ class TaskContextBegin(StrictModel):
     token: str = Field(pattern=r'^fuli-task-[a-zA-Z0-9-]{8,128}$')
     turn_id: str | None = Field(default=None, min_length=1, max_length=256)
     memory_revision: int | None = Field(default=None, ge=0)
+    work_log_required: bool = False
 
     @model_validator(mode='after')
     def require_project_for_agent(self):
@@ -32,6 +33,26 @@ class TaskContextAgentMemory(StrictModel):
     memory: ProjectAgentWorkingMemory
 
 
+class TaskContextAdoptAgent(StrictModel):
+    personal_space_id: str = Field(min_length=1, max_length=128)
+    personal_project_id: str = Field(min_length=1, max_length=128)
+    source_application: SourceApplication
+    task_id: str = Field(min_length=1, max_length=128)
+    agent_id: str = Field(min_length=1, max_length=128)
+
+
+class TaskWorkLog(StrictModel):
+    status: Literal['reported', 'completed', 'incomplete', 'failed', 'no_change', 'unreported']
+    summary: str = Field(min_length=1, max_length=2000)
+
+    @field_validator('summary')
+    @classmethod
+    def require_summary(cls, value):
+        if not value.strip():
+            raise ValueError('Work summary must not be blank')
+        return value.strip()
+
+
 class TaskContextCheckpoint(StrictModel):
     personal_space_id: str = Field(min_length=1, max_length=128)
     source_application: SourceApplication
@@ -41,6 +62,7 @@ class TaskContextCheckpoint(StrictModel):
     fingerprint: str = Field(pattern=r'^[a-f0-9]{64}$')
     capture_status: str | None = Field(default=None, max_length=128)
     agent_memory: TaskContextAgentMemory | None = None
+    work_log: TaskWorkLog | None = None
 
     @model_validator(mode='after')
     def reject_sensitive_values(self):

package/graph-provider/fuli_graph/task_context_routes.py

@@ -3,10 +3,14 @@ from typing import Annotated
 from fastapi import Query
 
 from .models import SourceApplication
-from .task_context_models import TaskContextBegin, TaskContextCheckpoint
+from .task_context_models import TaskContextBegin, TaskContextCheckpoint, TaskContextAdoptAgent
 
 
 def register_task_context_routes(application, store, Actor):
+    @application.put('/v1/task-contexts/{token}/agent')
+    async def adopt_agent(token: str, request: TaskContextAdoptAgent, actor: Actor):
+        return await store.adopt_task_context_agent(actor, token, request)
+
     @application.put('/v1/task-contexts')
     async def begin_context(request: TaskContextBegin, actor: Actor):
         return await store.begin_task_context(actor, request)

package/graph-provider/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fuli-graph-provider"
-version = "0.7.10-beta.7"
+version = "0.8.0"
 description = "Graphiti-backed personal and shared project provider for Fuli."
 requires-python = ">=3.12"
 dependencies = [

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "fuli-context",
-  "version": "0.7.10-beta.7",
+  "version": "0.8.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "fuli-context",
-      "version": "0.7.10-beta.7",
+      "version": "0.8.0",
       "license": "Apache-2.0",
       "dependencies": {
         "@hono/node-server": "2.0.12",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fuli-context",
-  "version": "0.7.10-beta.7",
+  "version": "0.8.0",
   "description": "Local-first collaboration relationship graph for AI agents.",
   "type": "module",
   "files": [

package/src/agent-tools/graph-definitions.js

@@ -98,7 +98,8 @@ const knowledgeConflictResolution = enumSchema([
 ]);
 const profileAspect = {
   type: ['string', 'null'],
-  enum: ['taste', 'personality', 'judgment_preference', null]
+  enum: ['taste', 'personality', 'judgment_preference', null],
+  description: 'Use "taste" for durable stylistic preference about the artifact itself, including writing voice, tone, wording, structure, formatting, and visual style; a writing or formatting style rule belongs here, not in judgment_preference. Use "judgment_preference" only for how a decision or process should be made, such as verification, risk, or sequencing rules. Use "personality" only for stable collaboration personality; an Agent-inferred personality item must stay confirmationStatus "pending" until a human confirms it.'
 };
 const sourceApplication = {
   type: ['string', 'null'],
@@ -301,11 +302,15 @@ export const GRAPH_TOOL_DEFINITIONS = [
   {
     name: 'checkpoint_task_knowledge',
     title: 'LIFECYCLE · Finish knowledge review',
-    description: 'Complete exactly one end-of-task knowledge review. Use capture_candidates only for a small durable batch supported by the task; captured Agent proposals remain pending unless the payload contains valid human or authoritative-source confirmation. Use retain_nothing when the turn produced no reusable knowledge. Never store raw transcripts, guesses, temporary logs, credentials, or disposable output.',
+    description: 'Complete exactly one end-of-task knowledge review. An assigned employee must include workLog with a concise result summary and truthful status even with retain_nothing. Include agentMemory with the loaded revision and merged notes when durable role memory changed. Use capture_candidates only for a small durable batch supported by the task; captured Agent proposals remain pending unless the payload contains valid human or authoritative-source confirmation. Use retain_nothing when the turn produced no reusable knowledge. Never store raw transcripts, guesses, temporary logs, credentials, or disposable output.',
     inputSchema: objectSchema({
       taskContextToken: id,
       disposition: enumSchema(['capture_candidates', 'retain_nothing']),
       reason: boundedString(2000),
+      workLog: objectSchema({
+        status: enumSchema(['reported', 'completed', 'incomplete', 'failed', 'no_change']),
+        summary: boundedString(2000)
+      }, ['status', 'summary']),
       capture: objectSchema(captureEpisodeFields, captureEpisodeRequired),
       agentMemory: objectSchema({
         expectedRevision: integerSchema({ minimum: 0 }),
@@ -743,7 +748,7 @@ export const GRAPH_TOOL_DEFINITIONS = [
   {
     name: 'coordinate_project_agent_task',
     title: 'WRITE · Prepare a host-executed Agent team',
-    description: 'Resolve the exact local project, let the Provider coordinator route one durable task, and assemble an isolated context bundle for every selected lead/collaborator. The result is a truthful host execution plan: Fuli persists identity, staffing, and memory scope, while the calling host must start real workers, report their concrete worker/executor evidence, and finish their lifecycle. This tool never claims that a selected Agent is online or that a worker was started.',
+    description: 'Resolve the exact local project, let the Provider coordinator route one durable task, and assemble an isolated context bundle for every selected lead/collaborator. Pass the current taskContextToken so a newly recruited lead can claim an initially unassigned task, including its blocked work. The result is a truthful host execution plan: Fuli persists identity, staffing, and memory scope, while the calling host must start real workers, report their concrete worker/executor evidence, and finish their lifecycle. This tool never claims that a selected Agent is online or that a worker was started.',
     inputSchema: projectAgentTaskCoordinateInput
   },
   {
@@ -815,12 +820,16 @@ export const GRAPH_TOOL_DEFINITIONS = [
   {
     name: 'update_project_agent_coordination_policy',
     title: 'WRITE · Set project Agent continuity policy',
-    description: 'Persist the exact project switches for asking before recruitment and automatically reusing its previous effective Agent. This changes policy only and never starts a worker.',
+    description: 'Persist project collaboration switches and an optional stable team lead with members. HR and employee project managers remain peer roles and cannot be team members. Omitted team fields preserve the current team. Read policy first and send expectedUpdatedAt to prevent overwriting concurrent edits. This changes policy only and never starts a worker.',
     inputSchema: objectSchema({
       personalSpaceId: id,
       personalProjectId: id,
       askBeforeRecruitment: booleanSchema(),
-      autoReusePreviousAgent: booleanSchema()
+      autoReusePreviousAgent: booleanSchema(),
+      autoGrowTeam: booleanSchema(),
+      teamLeadAgentId: nullableStringSchema(),
+      teamMemberAgentIds: arraySchema(id, { maxItems: 32, uniqueItems: true }),
+      expectedUpdatedAt: { ...dateTime, type: ['string', 'null'] }
     }, [
       'personalSpaceId', 'personalProjectId',
       'askBeforeRecruitment', 'autoReusePreviousAgent'

package/src/agent-tools/project-agent-definitions.js

@@ -154,6 +154,7 @@ export const projectAgentTaskSubmitInput = objectSchema({
   'workKind', 'routingReason'
 ]);
 export const projectAgentTaskCoordinateInput = objectSchema({
+  taskContextToken: id,
   projectPath: boundedString(4096),
   idempotencyKey,
   title: boundedString(160),