interaqt 2.0.4 → 3.0.0

package/agent/agentspace/knowledge/usage/07-payload-parameters.md

@@ -27,15 +27,16 @@ const CreatePost = Interaction.create({
 ```javascript
 PayloadItem.create({
   name: 'itemName',           // Parameter name (required)
+  type: 'string',             // Primitive type check (optional)
   base: Entity,               // Reference to Entity/Relation (optional)
   isRef: true,                // Whether it's a reference with id (default: false)
   required: true,             // Whether this parameter is required (default: false)
-  isCollection: true,         // Whether it's an array (default: false)
-  attributives: Attributive,  // Validation rules (optional)
-  itemRef: Entity             // Reference to other concepts (optional)
+  isCollection: true          // Whether it's an array (default: false)
 })
 ```
 
+To validate payload **contents** (e.g. "only published posts can be shared"), write the check as a `Condition` on the Interaction — see [Payload Validation with Conditions](#payload-validation-with-conditions) below.
+
 ## Basic Payload Usage
 
 ### Simple Parameters Without Entity Reference
@@ -82,7 +83,7 @@ await controller.callInteraction('SendMessage', {
 **Important**: When `base` is not specified, the framework only checks:
 - Whether required parameters are present
 - Whether collection parameters are arrays
-- No concept validation or attributive checks are performed
+- No concept validation is performed
 
 ### Parameters with Entity Reference
 
@@ -242,18 +243,23 @@ await controller.callInteraction('TagPosts', {
 });
 ```
 
-## Payload Validation with Attributives
+## Payload Validation with Conditions
 
-### Basic Attributive Validation
+Payload content checks are written as `Condition`s on the Interaction. A condition callback receives the full event args (`user`, `payload`, `query`, `activityId`) with the Controller as `this`, so it can read the payload and query storage. It must return a strict boolean — any non-boolean result fails the check (fail-closed).
 
-When PayloadItem has both `base` and `attributives`, the framework validates the payload data:
+### Basic Condition Validation
 
 ```javascript
-// Define validation attributive
-const PublishedPost = Attributive.create({
-  name: 'PublishedPost',
-  content: function(post, eventArgs) {
-    return post.status === 'published';
+// Define validation condition
+const PublishedPostOnly = Condition.create({
+  name: 'PublishedPostOnly',
+  content: async function(event) {
+    const post = await this.system.storage.findOne('Post',
+      MatchExp.atom({ key: 'id', value: ['=', event.payload.post.id] }),
+      undefined,
+      ['status']
+    );
+    return post?.status === 'published';
   }
 });
 
@@ -266,11 +272,11 @@ const SharePost = Interaction.create({
         name: 'post',
         base: Post,
         isRef: true,
-        required: true,
-        attributives: PublishedPost  // Only published posts can be shared
+        required: true
       })
     ]
-  })
+  }),
+  conditions: PublishedPostOnly  // Only published posts can be shared
 });
 
 // This will succeed:
@@ -292,20 +298,30 @@ await controller.callInteraction('SharePost', {
 
 ### Complex Validation with BoolExp
 
-You can combine multiple attributives using BoolExp:
+You can combine multiple conditions using `Conditions.create` and BoolExp:
 
 ```javascript
-const ActiveTag = Attributive.create({
-  name: 'ActiveTag',
-  content: function(tag, eventArgs) {
-    return tag.isActive === true;
+const TagsAreActive = Condition.create({
+  name: 'TagsAreActive',
+  content: async function(event) {
+    const tags = await this.system.storage.find('Tag',
+      MatchExp.atom({ key: 'id', value: ['in', event.payload.tags.map(tag => tag.id)] }),
+      undefined,
+      ['isActive']
+    );
+    return tags.every(tag => tag.isActive === true);
   }
 });
 
-const PopularTag = Attributive.create({
-  name: 'PopularTag',
-  content: function(tag, eventArgs) {
-    return tag.usageCount > 100;
+const TagsArePopular = Condition.create({
+  name: 'TagsArePopular',
+  content: async function(event) {
+    const tags = await this.system.storage.find('Tag',
+      MatchExp.atom({ key: 'id', value: ['in', event.payload.tags.map(tag => tag.id)] }),
+      undefined,
+      ['usageCount']
+    );
+    return tags.every(tag => tag.usageCount > 100);
   }
 });
 
@@ -318,26 +334,32 @@ const AddTags = Interaction.create({
         name: 'tags',
         base: Tag,
         isRef: true,
-        isCollection: true,
-        // Tags must be both active AND popular
-        attributives: Attributives.create({
-          content: BoolExp.atom(ActiveTag).and(BoolExp.atom(PopularTag))
-        })
+        isCollection: true
       })
     ]
+  }),
+  // Tags must be both active AND popular
+  conditions: Conditions.create({
+    content: BoolExp.atom(TagsAreActive).and(TagsArePopular)
   })
 });
 ```
 
 ### Validation for Collections
 
-When `isCollection` is true, attributives are checked for **every item** in the array:
+When a payload item is a collection, write the condition to check **every item** in the array:
 
 ```javascript
-const VerifiedUser = Attributive.create({
-  name: 'VerifiedUser',
-  content: function(user, eventArgs) {
-    return user.isVerified === true;
+const AllUsersVerified = Condition.create({
+  name: 'AllUsersVerified',
+  content: async function(event) {
+    const users = await this.system.storage.find('User',
+      MatchExp.atom({ key: 'id', value: ['in', event.payload.users.map(user => user.id)] }),
+      undefined,
+      ['isVerified']
+    );
+    return users.length === event.payload.users.length &&
+           users.every(user => user.isVerified === true);
   }
 });
 
@@ -350,11 +372,11 @@ const InviteUsers = Interaction.create({
         name: 'users',
         base: User,
         isRef: true,
-        isCollection: true,
-        attributives: VerifiedUser  // ALL users must be verified
+        isCollection: true
       })
     ]
-  })
+  }),
+  conditions: AllUsersVerified  // ALL users must be verified
 });
 
 // This will fail if ANY user in the array is not verified
@@ -386,9 +408,8 @@ Framework behavior:
 - ✅ Checks if required parameter is present
 - ✅ Checks if collection parameter is an array (when isCollection: true)
 - ❌ Does NOT perform concept validation
-- ❌ Does NOT check attributives
 - ❌ Does NOT validate data structure
-- **You must handle validation in your own logic**
+- **You must handle validation in your own logic (e.g. through conditions)**
 
 ### When base IS specified
 
@@ -396,8 +417,7 @@ Framework behavior:
 PayloadItem.create({ 
   name: 'post',
   base: Post,      // Entity reference
-  isRef: true,
-  attributives: PublishedPost
+  isRef: true
 })
 ```
 
@@ -405,8 +425,8 @@ Framework behavior:
 - ✅ Checks if required parameter is present
 - ✅ Validates the data matches the concept (Entity/Relation)
 - ✅ If isRef: true, verifies id exists and fetches full record
-- ✅ If attributives exist, validates the data against them
-- ✅ For collections, validates every item
+- ✅ For collections, validates every item against the concept
+- Content-level rules (e.g. "post must be published") are expressed as conditions on the Interaction
 
 ### Payload Storage Behavior
 
@@ -436,11 +456,11 @@ const CreateArticle = Interaction.create({
 
 ```javascript
 // ✅ Good: Use base for entity-related data
+// (content rules like "user must be active" go into the interaction's conditions)
 PayloadItem.create({ 
   name: 'targetUser',
   base: User,
-  isRef: true,
-  attributives: ActiveUser
+  isRef: true
 })
 
 // ✅ Good: Simple parameters without base
@@ -490,12 +510,17 @@ const UpdateUserProfile = Interaction.create({
 ### 3. Consistent Validation Patterns
 
 ```javascript
-// Define reusable attributives
-const CanBeEdited = Attributive.create({
-  name: 'CanBeEdited',
-  content: function(item, eventArgs) {
-    return item.status !== 'locked' && 
-           item.createdBy === eventArgs.user.id;
+// Define a reusable condition factory
+const canBeEdited = (entityName, payloadKey) => Condition.create({
+  name: `${entityName}CanBeEdited`,
+  content: async function(event) {
+    const item = await this.system.storage.findOne(entityName,
+      MatchExp.atom({ key: 'id', value: ['=', event.payload[payloadKey].id] }),
+      undefined,
+      ['status', 'createdBy']
+    );
+    return !!item && item.status !== 'locked' && 
+           item.createdBy === event.user.id;
   }
 });
 
@@ -506,11 +531,11 @@ const EditPost = Interaction.create({
       PayloadItem.create({ 
         name: 'post',
         base: Post,
-        isRef: true,
-        attributives: CanBeEdited
+        isRef: true
       })
     ]
-  })
+  }),
+  conditions: canBeEdited('Post', 'post')
 });
 
 const EditComment = Interaction.create({
@@ -519,11 +544,11 @@ const EditComment = Interaction.create({
       PayloadItem.create({ 
         name: 'comment',
         base: Comment,
-        isRef: true,
-        attributives: CanBeEdited
+        isRef: true
       })
     ]
-  })
+  }),
+  conditions: canBeEdited('Comment', 'comment')
 });
 ```
 
@@ -531,17 +556,15 @@ const EditComment = Interaction.create({
 
 ```javascript
 // In your application code
-try {
-  const result = await controller.callInteraction('SharePost', {
-    user: currentUser,
-    payload: { post: { id: postId } }
-  });
-} catch (error) {
-  if (error instanceof AttributeError) {
-    if (error.type === 'post not match attributive') {
-      // Handle validation failure
-      console.error('Cannot share: Post is not published');
-    }
+const result = await controller.callInteraction('SharePost', {
+  user: currentUser,
+  payload: { post: { id: postId } }
+});
+
+if (result.error) {
+  if (result.error.type === 'condition check failed') {
+    // Handle validation failure; result.error.error.data.name is the failing condition
+    console.error('Cannot share: Post is not published');
   }
 }
 ```
@@ -579,15 +602,15 @@ NOT setting base property maintains the same functionality but avoids the resolu
 
 The Payload system in interaqt provides a powerful way to:
 - Define structured interaction parameters
-- Enforce validation rules through attributives
+- Enforce content validation rules through conditions
 - Ensure type safety with entity references
 - Handle both simple data and complex entity relationships
 
 Key points to remember:
-- **With base**: Framework handles validation and attributive checks
+- **With base**: Framework handles concept validation and reference resolution
 - **Without base**: You handle validation in your own logic
 - **isRef**: Distinguishes between references and new data
-- **attributives**: Only work when base is specified
-- **isCollection**: Validates every item in arrays
+- **conditions**: Payload content rules live on the Interaction, not on PayloadItem
+- **isCollection**: Validates every item in arrays against the concept
 
 By properly using Payload and PayloadItem, you can build robust, type-safe interactions that validate data at the framework level, reducing the need for manual validation code and improving system reliability. 

package/agent/agentspace/knowledge/usage/11-global-dictionaries.md

@@ -470,6 +470,16 @@ async function setDefaultConfig() {
 ### 10.4.3 Conditional Logic Based on Dictionaries
 
 ```typescript
+// Use Condition to control permissions based on dictionary values
+const MaxUsersNotReached = Condition.create({
+  name: 'MaxUsersNotReached',
+  content: async function(this: Controller, event) {
+    const currentUserCount = await this.system.storage.get('state', 'totalUsers');
+    const maxUsers = await this.system.storage.get('state', 'maxUsers');
+    return currentUserCount < maxUsers;
+  }
+});
+
 // Using dictionary values for conditional logic in interactions
 const createUserInteraction = Interaction.create({
   name: 'createUser',
@@ -481,21 +491,10 @@ const createUserInteraction = Interaction.create({
         base: userEntity
       })
     ]
-  })
+  }),
+  // Dictionary-based permission control
+  conditions: MaxUsersNotReached
 });
-
-// Use Attributive to control permissions based on dictionary values
-const MaxUsersReachedAttributive = Attributive.create({
-  name: 'MaxUsersNotReached',
-  content: async function(context: any) {
-    const currentUserCount = await context.system.storage.get('state', 'totalUsers');
-    const maxUsers = await context.system.storage.get('state', 'maxUsers');
-    return currentUserCount < maxUsers;
-  }
-});
-
-// Add dictionary-based permission control to interaction
-createUserInteraction.attributives = [MaxUsersReachedAttributive];
 ```
 
 ### 10.4.4 Combining Dictionaries with Computations

package/agent/agentspace/knowledge/usage/13-testing.md

@@ -645,11 +645,11 @@ describe('Approval Process Activity', () => {
 });
 ```
 
-## 12.3 Testing Permissions and Attributives
+## 12.3 Testing Permissions (Conditions)
 
 > **Important: Correct Error Handling Approach**
 > 
-> The interaqt framework automatically catches all errors (including Attributive validation failures, insufficient permissions, etc.) and returns error information through the `error` field in the return value. The framework **does not throw uncaught exceptions**.
+> The interaqt framework automatically catches all errors (including condition check failures, insufficient permissions, etc.) and returns error information through the `error` field in the return value. The framework **does not throw uncaught exceptions**.
 > 
 > Therefore, when writing tests:
 > - ✅ **Correct approach**: Check the `error` field in the return value

package/agent/agentspace/knowledge/usage/14-api-reference.md

@@ -1124,17 +1124,18 @@ PayloadItem.create(config: PayloadItemConfig): KlassInstance<typeof PayloadItem>
 
 **Parameters**
 - `config.name` (string, required): Parameter name
-- `config.base` (Entity, optional): Parameter entity type, only needed when isRef is true
+- `config.type` (string, optional): Primitive type check ('string', 'number', 'boolean', 'object')
+- `config.base` (Entity|Relation, optional): Parameter entity type, only needed when isRef is true
 - `config.isRef` (boolean, optional): Whether it's a reference type, defaults to false
 - `config.required` (boolean, optional): Whether it's required, defaults to false
 - `config.isCollection` (boolean, optional): Whether it's a collection type, defaults to false
-- `config.attributives` (Attributive|Attributives, optional): Parameter permission attributives
-- `config.itemRef` (Attributive|Entity, optional): Used to reference entities defined in other interactions within Activity
+
+Payload **content** validation (e.g. "post must have title and content") is expressed as `conditions` on the Interaction — see Condition.create().
 
 **Examples**
 ```typescript
 // Reference existing user
-const userRef = PayloadItem.create({
+const userItem = PayloadItem.create({
     name: 'user',
     base: User,
     isRef: true,
@@ -1145,13 +1146,15 @@ const userRef = PayloadItem.create({
 const postData = PayloadItem.create({
     name: 'postData',
     base: Post,
-    required: true,
-    attributives: Attributive.create({
-        name: 'ValidPost',
-        content: function(post) {
-            return post.title && post.content
-        }
-    })
+    required: true
+})
+
+// Content validation goes on the Interaction's conditions
+const ValidPost = Condition.create({
+    name: 'ValidPost',
+    content: async function(event) {
+        return !!(event.payload.postData.title && event.payload.postData.content)
+    }
 })
 
 // Collection type reference
@@ -1159,19 +1162,7 @@ const reviewersItem = PayloadItem.create({
     name: 'reviewers',
     base: User,
     isRef: true,
-    isCollection: true,
-    attributives: Attributives.create({
-        content: BoolAtomData.create({data: ReviewerAttr, type: 'atom'})
-    })
-})
-
-// Activity item reference
-const activityItem = PayloadItem.create({
-    name: 'to',
-    base: User,
-    isRef: true,
-    attributives: boolExpToAttributives(BoolExp.atom(OtherAttr)),
-    itemRef: userRefB
+    isCollection: true
 })
 ```
 
@@ -1244,7 +1235,7 @@ const ApprovalTransfer = Transfer.create({
 
 ### Condition.create()
 
-Create activity execution condition.
+Create an execution condition — the single guard concept for interactions (permission checks, payload content checks, activity user binding).
 
 **Syntax**
 ```typescript
@@ -1253,16 +1244,21 @@ Condition.create(config: ConditionConfig): KlassInstance<typeof Condition>
 
 **Parameters**
 - `config.name` (string, required): Condition name
-- `config.content` (function, required): Condition judgment function
+- `config.content` (function, required): Condition judgment function. Called with the Controller as `this` and the full event args (`user`, `payload`, `query`, `activityId`). Must return a strict boolean — any non-boolean result fails the check (fail-closed).
 
 **Examples**
 ```typescript
 const OrderValueCondition = Condition.create({
     name: 'highValueOrder',
-    content: function(order) {
-        return order.totalAmount > 1000
+    content: async function(event) {
+        return event.payload.order.totalAmount > 1000
     }
 })
+
+// Combine multiple conditions with Conditions.create + BoolExp
+const AdminHighValueOrder = Conditions.create({
+    content: BoolExp.atom(AdminOnly).and(OrderValueCondition)
+})
 ```
 
 ## 13.5 System-Related APIs
@@ -1476,44 +1472,6 @@ const condition = MatchExp.fromObject({
 // Equivalent to: status='active' AND age=25 AND city='Beijing'
 ```
 
-### Attributive.create()
-
-Create permission attributive for access control.
-
-**Syntax**
-```typescript
-Attributive.create(config: AttributiveConfig): KlassInstance<typeof Attributive>
-```
-
-**Parameters**
-- `config.name` (string, optional): Attributive name
-- `config.content` (function, required): Permission judgment function
-- `config.isRef` (boolean, optional): Whether it's a reference
-
-**Examples**
-```typescript
-// Admin permission
-const AdminAttributive = Attributive.create({
-    name: 'Admin',
-    content: function(target, { user }) {
-        return user.role === 'admin'
-    }
-})
-
-// Resource owner permission
-const OwnerAttributive = Attributive.create({
-    name: 'Owner',
-    content: function(target, { user }) {
-        return target.userId === user.id
-    }
-})
-
-// Combined permissions (using BoolExp)
-const AdminOrOwnerAttributives = boolExpToAttributives(
-    BoolExp.atom(AdminAttributive).or(OwnerAttributive)
-)
-```
-
 ### BoolExp
 
 Boolean expression builder for constructing complex logical expressions.

package/agent/agentspace/knowledge/usage/16-frontend-page-design-guide.md

@@ -14,7 +14,7 @@ This document guides how to systematically design frontend page architecture and
 ### 2. Reactive Data Display
 - **Reactive Computations**: All properties with `computation` should be displayed in real-time in the interface
 - **State-Aware**: Dynamically display different operation options based on entity state
-- **Permission Control**: Control interface element visibility based on Attributive definitions
+- **Permission Control**: Control interface element visibility based on Condition definitions
 
 ### 3. User Experience Consistency
 - **Operation Feedback**: Every interaction operation should have clear feedback
@@ -191,7 +191,7 @@ Operation History Area (Optional)
 ```
 
 #### 2.2 Design Points
-- **Permission Control**: Dynamically display action buttons based on Attributive
+- **Permission Control**: Dynamically display action buttons based on Condition
 - **State Awareness**: Display different operation options based on entity state
 - **Association Display**: Reasonably display associated entities, avoid information overload
 - **Operation Feedback**: Clear operation result notifications
@@ -340,7 +340,7 @@ For properties containing `computation`:
 - **Transition Hints**: Display possible state transition operations
 
 #### 2.2 Conditional Operation Display
-Based on permission control defined by Attributive:
+Based on permission control defined by Condition:
 - **Dynamic Buttons**: Dynamically display action buttons based on permissions
 - **Disabled States**: Show disabled operations when conditions aren't met
 - **Permission Hints**: Explain why certain operations are unavailable

package/agent/agentspace/knowledge/usage/18-api-exports-reference.md

@@ -40,9 +40,7 @@ import {
   RealTime,
   MathResolver,
   
-  // Attributive and Conditions
-  Attributive,
-  Attributives,
+  // Conditions
   Condition,
   Conditions,
   
@@ -95,8 +93,7 @@ import {
   RelationBasedEvery,  // Only 'Every' exists
   InteractionEvent,    // Correct name is 'InteractionEventEntity'
   FilteredEntity,      // Created via Entity.create with baseEntity
-  SideEffect,          // Not a direct export
-  DataAttributive      // Use Attributive for all purposes
+  SideEffect           // Not a direct export
 } from 'interaqt';
 ```
 

package/agent/agentspace/knowledge/usage/README.md

@@ -22,7 +22,7 @@ Master declarative data computation.
 ### 6. 🎮 [Interactions](./05-interactions.md)
 Learn how to define user interactions (Remember: Action is just an identifier!).
 
-### 7. 🔐 [Attributive Permissions](./06-attributive-permissions.md)
+### 7. 🔐 [Permission Control (Conditions)](./06-attributive-permissions.md)
 Understand how to control access permissions.
 
 ### 8. 📦 [Payload Parameters](./07-payload-parameters.md)
@@ -124,7 +124,7 @@ Remember: **Stop thinking "how to do", start thinking "what is"**!
 ### Reactive System
 5. [Reactive Computations](./04-reactive-computations.md) - Declarative data computation
 6. [Interactions](./05-interactions.md) - User interaction definition
-7. [Attributive Permissions](./06-attributive-permissions.md) - Access control
+7. [Permission Control (Conditions)](./06-attributive-permissions.md) - Access control
 8. [Payload Parameters](./07-payload-parameters.md) - Interaction parameter validation
 9. [Activities](./08-activities.md) - Complex business processes
 

package/agent/skill/interaqt-reference.md

@@ -125,14 +125,15 @@ Payload.create(args: {
 PayloadItem.create(args: {
   name: string                        // Parameter name
   type: string                        // Required: data type
-  base?: EntityInstance               // Entity reference for validation
+  base?: EntityInstance | RelationInstance  // Entity/Relation reference for validation
   isRef?: boolean                     // true = reference by ID to existing entity
   required?: boolean                  // true = mandatory parameter
   isCollection?: boolean             // true = array of items
-  itemRef?: AttributiveInstance | EntityInstance  // Reference to entities defined in other interactions (for Activity)
 }): PayloadItemInstance
 ```
 
+Payload content validation is expressed as `conditions` on the Interaction (see Condition.create).
+
 ---
 
 ## Count.create
@@ -530,19 +531,6 @@ MatchExp.atom({ key: 'author.name', value: ['=', 'Alice'] })
 
 ---
 
-## Attributive.create
-
-```typescript
-Attributive.create(args: {
-  name?: string
-  content: (record: any, eventArgs: any) => boolean
-}): AttributiveInstance
-```
-
-Used on Interaction `userAttributives` to validate user context.
-
----
-
 ## BoolExp
 
 ```typescript
@@ -551,7 +539,7 @@ boolExp.and(other: BoolExp | T): BoolExp
 boolExp.or(other: BoolExp | T): BoolExp
 ```
 
-Combines multiple Attributives, Conditions, or other expressions for complex logic.
+Combines multiple Conditions, match atoms, or other expressions for complex logic.
 
 ---
 
@@ -568,8 +556,9 @@ Conditions.create(args: {
 }): ConditionsInstance
 ```
 
-- `content` returns `true` to allow, `false` to reject
+- `content` returns `true` to allow, `false` to reject; any non-boolean result fails the check (fail-closed)
 - `this` is bound to Controller — can access `this.system.storage`
+- `event` contains `user`, `payload`, `query`, `activityId` — use it for user checks, payload content checks, and activity user binding
 - Failed conditions return `{ error: { type: 'condition check failed' } }`
 
 ---
@@ -652,7 +641,6 @@ import {
   Expression, Inequality, Equation, MathResolver,
 
   // Validation & conditions
-  Attributive, Attributives,
   Condition, Conditions,
 
   // Data policy