interaqt 2.0.0-alpha.0 → 2.0.1

package/README.md

@@ -99,6 +99,7 @@ import {
   Payload, PayloadItem, Controller, MonoSystem,
   Count, Transform, InteractionEventEntity
 } from 'interaqt'
+import { PGLiteDB } from 'interaqt/drivers'
 
 // --- Define your data model ---
 

package/agent/agentspace/knowledge/generator/api-reference.md

@@ -225,7 +225,7 @@ const deletionStateMachine = StateMachine.create({
             current: NON_DELETED_STATE,
             next: DELETED_STATE,
             computeTarget: function(event) {
-                return { id: event.payload.userId }
+                return { id: event.record.payload.userId }
             }
         })
     ]
@@ -313,7 +313,7 @@ deletionProperty.computation = StateMachine.create({
             current: NON_DELETED_STATE,
             next: DELETED_STATE,
             computeTarget: function(event) {
-                return { id: event.payload.articleId }
+                return { id: event.record.payload.articleId }
             }
         })
     ]
@@ -799,6 +799,7 @@ const userTotalScore = Property.create({
     type: 'number',
     computation: WeightedSummation.create({
         property: 'scores',  // Use property name from relation
+        attributeQuery: ['multiplier', 'points'],  // Required when callback reads fields
         callback: function(scoreRecord) {
             return {
                 weight: scoreRecord.multiplier || 1,
@@ -811,6 +812,7 @@ const userTotalScore = Property.create({
 // Global weighted summation
 const globalWeightedScore = WeightedSummation.create({
     record: ScoreRecord,
+    attributeQuery: ['difficulty', 'score'],  // Required when callback reads fields
     callback: function(record) {
         return {
             weight: record.difficulty,
@@ -1698,6 +1700,16 @@ Custom.create(config: CustomConfig): CustomInstance
 
 If `incrementalCompute` or `incrementalPatchCompute` is provided without `incrementalDataDeps` or `planIncremental`, runtime setup fails with `ComputationProtocolError`. Incremental callbacks receive only the planned partial `dataDeps`, not all declared dependencies.
 
+**Mutation event snapshots**
+
+Snapshot shapes differ by event type:
+
+- `create`: `record` = the written fields (defaults + payload), `oldRecord` = `undefined`
+- `update`: `record` = **only the changed fields** (plus `id`), `oldRecord` = full pre-update snapshot
+- `delete`: `record` = full deleted snapshot, `oldRecord` = `undefined`
+
+Never read a field straight off `mutationEvent.record` on update unless you know it was part of the update — it silently evaluates to `undefined` otherwise and corrupts the incremental result. Reconstruct the full new state with `{ ...mutationEvent.oldRecord, ...mutationEvent.record }`, or re-fetch the record via `this.controller.system.storage.findOne(...)` when computed columns or related data are needed (this is what the built-in aggregations do). The same applies to the third `record` parameter: it is only guaranteed to identify the dirty record, not to carry all of its fields.
+
 **Retry safety**
 
 Custom `compute`, `incrementalCompute`, `incrementalPatchCompute`, and `asyncReturn` callbacks may be replayed after transaction retry. Keep them deterministic and avoid irreversible external IO. Put post-commit external work in `recordMutationSideEffects`.
@@ -1772,9 +1784,20 @@ const counterDict = Dictionary.create({
         },
         incrementalCompute: async function(lastValue, mutationEvent, record, dataDeps) {
             console.log('Previous value:', lastValue);
-            const delta = mutationEvent.type === 'delete'
-                ? -(mutationEvent.oldRecord?.value || 0)
-                : (mutationEvent.record?.value || 0) - (mutationEvent.oldRecord?.value || 0);
+            // CAUTION mutation event snapshot shapes differ by type:
+            // - create: record = written fields (defaults + payload), oldRecord = undefined
+            // - update: record = ONLY the changed fields (+ id), oldRecord = full pre-update snapshot
+            // - delete: record = full deleted snapshot, oldRecord = undefined
+            // Reading a field straight off mutationEvent.record on update silently yields
+            // undefined when that field was not part of the update. Reconstruct the full
+            // new state by overlaying the changed fields on the old snapshot.
+            const newRecord = mutationEvent.type === 'delete'
+                ? undefined
+                : { ...(mutationEvent.oldRecord || {}), ...(mutationEvent.record || {}) };
+            const previousRecord = mutationEvent.type === 'delete'
+                ? mutationEvent.record
+                : mutationEvent.oldRecord;
+            const delta = (newRecord?.value || 0) - (previousRecord?.value || 0);
             const total = (lastValue?.total || 0) + delta;
             
             return {

package/agent/agentspace/knowledge/generator/computation-implementation.md

@@ -124,7 +124,11 @@ When using `InteractionEventEntity` as the Transform input source, understand th
      states: [updatedState],
      transfers: [
        StateTransfer.create({
-         trigger: UpdateStyleInteraction,
+         trigger: {
+           recordName: InteractionEventEntity.name,
+           type: 'create',
+           record: { interactionName: UpdateStyleInteraction.name }
+         },
          current: updatedState,
          next: updatedState,
          computeTarget: (mutationEvent) => ({ id: mutationEvent.record.payload.id })
@@ -142,7 +146,11 @@ When using `InteractionEventEntity` as the Transform input source, understand th
      initialState: activeState,  // StateMachine controls initial value
      transfers: [
        StateTransfer.create({
-         trigger: DeleteStyleInteraction,
+         trigger: {
+           recordName: InteractionEventEntity.name,
+           type: 'create',
+           record: { interactionName: DeleteStyleInteraction.name }
+         },
          current: activeState,
          next: deletedState,
          computeTarget: (mutationEvent) => ({ id: mutationEvent.record.payload.id })
@@ -336,19 +344,30 @@ Used for status changes and field updates.
 
 **🔴 IMPORTANT: StateTransfer Trigger Parameter**
 
-The `trigger` parameter in `StateTransfer.create()` must ALWAYS be an Interaction instance reference, NOT a string!
+The `trigger` parameter in `StateTransfer.create()` is a **RecordMutationEventPattern** — an object pattern matched against record mutation events (`{ recordName, type, keys?, record?, oldRecord? }`). It is NOT a string and NOT an Interaction instance. For interaction-triggered transitions, match the creation of the interaction's event record:
 
 ```typescript
-// ❌ WRONG: Using string as trigger
+// ❌ WRONG: Using a string as trigger
 StateTransfer.create({
-  trigger: 'PublishStyle',  // ERROR! Don't use string!
+  trigger: 'PublishStyle',  // ERROR! Never matches any event
   current: draftState,
   next: activeState
 })
 
-// ✅ CORRECT: Using Interaction instance reference
+// ❌ WRONG: Using an Interaction instance as trigger
 StateTransfer.create({
-  trigger: PublishStyle,  // Correct! Reference to Interaction instance
+  trigger: PublishStyle,  // ERROR! Never matches any event
+  current: draftState,
+  next: activeState
+})
+
+// ✅ CORRECT: Match the interaction's event record creation
+StateTransfer.create({
+  trigger: {
+    recordName: InteractionEventEntity.name,
+    type: 'create',
+    record: { interactionName: PublishStyle.name }
+  },
   current: draftState,
   next: activeState
 })
@@ -397,13 +416,21 @@ statusProperty.computation = StateMachine.create({
     StateTransfer.create({
       current: draftState,
       next: activeState,
-      trigger: PublishStyle,
+      trigger: {
+        recordName: InteractionEventEntity.name,
+        type: 'create',
+        record: { interactionName: PublishStyle.name }
+      },
       computeTarget: (mutationEvent) => ({ id: mutationEvent.record.payload.id })
     }),
     StateTransfer.create({
       current: activeState,
       next: offlineState,
-      trigger: DeleteStyle,
+      trigger: {
+        recordName: InteractionEventEntity.name,
+        type: 'create',
+        record: { interactionName: DeleteStyle.name }
+      },
       computeTarget: (mutationEvent) => ({ id: mutationEvent.record.payload.id })
     })
   ]
@@ -443,7 +470,11 @@ updatedAtProperty.computation = StateMachine.create({
     StateTransfer.create({
       current: updatedState,
       next: updatedState,  // Self-loop to same state
-      trigger: UpdateStyle,
+      trigger: {
+        recordName: InteractionEventEntity.name,
+        type: 'create',
+        record: { interactionName: UpdateStyle.name }
+      },
       computeTarget: (mutationEvent) => ({ id: mutationEvent.record.payload.id })
     })
   ]
@@ -506,7 +537,11 @@ modificationInfoProperty.computation = StateMachine.create({
     StateTransfer.create({
       current: modifiedState,
       next: modifiedState,
-      trigger: UpdateArticle,
+      trigger: {
+        recordName: InteractionEventEntity.name,
+        type: 'create',
+        record: { interactionName: UpdateArticle.name }
+      },
       computeTarget: (mutationEvent) => ({ id: mutationEvent.record.payload.id })
     })
   ]
@@ -869,7 +904,11 @@ updatedAtProperty.computation = StateMachine.create({
     StateTransfer.create({
       current: updatedState,
       next: updatedState,
-      trigger: UpdateStyle,
+      trigger: {
+        recordName: InteractionEventEntity.name,
+        type: 'create',
+        record: { interactionName: UpdateStyle.name }
+      },
       computeTarget: (mutationEvent) => ({ id: mutationEvent.record.payload.id })
     })
   ]
@@ -905,7 +944,11 @@ statusProperty.computation = StateMachine.create({
     StateTransfer.create({
       current: activeState,
       next: offlineState,
-      trigger: DeleteStyle,
+      trigger: {
+        recordName: InteractionEventEntity.name,
+        type: 'create',
+        record: { interactionName: DeleteStyle.name }
+      },
       computeTarget: (mutationEvent) => ({ id: mutationEvent.record.payload.id })
     })
   ]
@@ -977,7 +1020,11 @@ updatedAtProperty.computation = StateMachine.create({
     StateTransfer.create({
       current: updatedState,
       next: updatedState,
-      trigger: UpdateInteraction,
+      trigger: {
+        recordName: InteractionEventEntity.name,
+        type: 'create',
+        record: { interactionName: UpdateInteraction.name }
+      },
       computeTarget: (mutationEvent) => ({ id: mutationEvent.record.payload.id })
     })
   ]

package/agent/agentspace/knowledge/usage/00-mindset-shift.md

@@ -215,6 +215,7 @@ const Product = Entity.create({
       name: 'currentStock',
       computation: WeightedSummation.create({
         record: OrderItemRelation,
+        attributeQuery: ['quantity'],  // Required when callback reads fields
         callback: (orderItem) => ({
           weight: -1,  // Reduce inventory
           value: orderItem.quantity
@@ -225,6 +226,7 @@ const Product = Entity.create({
       name: 'totalSales',
       computation: WeightedSummation.create({
         record: OrderItemRelation,
+        attributeQuery: ['quantity'],  // Required when callback reads fields
         callback: (orderItem) => ({
           weight: 1,
           value: orderItem.quantity

package/agent/agentspace/knowledge/usage/04-reactive-computations.md

@@ -89,6 +89,11 @@ Custom computations are different because interaqt cannot inspect user callback
 
 Custom incremental computations must declare an incremental plan. Use `incrementalDataDeps: [...]` for the common case, or `planIncremental(event, record, context)` when the computation needs to choose between incremental, full recompute, and skip per event. Incremental callbacks receive only the planned partial `dataDeps`; the runtime no longer resolves all declared dependencies before incremental execution.
 
+Two contract details for Custom `dataDeps`:
+
+- **`records` dataDeps must declare `attributeQuery`.** Setup fails fast otherwise, because an undeclared field set would resolve to id-only records and field updates would never re-trigger the computation. Declare the fields your `compute` reads (e.g. `attributeQuery: ['price']`), or pass an explicit `attributeQuery: []` when the computation only depends on record membership (create/delete).
+- **`incrementalDataDeps` names the dependency values to resolve and pass into `incrementalCompute`; it is not an event filter.** Events from every declared `dataDep` reach `incrementalCompute` — distinguish sources by `event.recordName` inside the callback, or use `planIncremental` to return different plans per dependency. (Create/update events of unrelated global dicts are already filtered by key at the source-map level and never trigger the computation.)
+
 Because retry replays the transaction attempt, `guard`, `mapEventData`, `resolve`, computation callbacks, `afterDispatch`, and `asyncReturn` must be deterministic and retry-safe. Put irreversible external IO in `postCommit` for interaction-specific effects or `recordMutationSideEffects` for mutation-driven effects; both run after the final commit.
 
 ### Scoped Atomic Sequences
@@ -490,6 +495,7 @@ const Student = Entity.create({
       defaultValue: () => 0,
       computation: WeightedSummation.create({
         record: StudentGrades,
+        attributeQuery: [['target', { attributeQuery: ['credit', 'score'] }]],  // Required when callback reads fields
         callback: (relation) => ({
           weight: relation.target.credit,
           value: relation.target.score
@@ -503,6 +509,7 @@ const Student = Entity.create({
       defaultValue: () => 0,
       computation: WeightedSummation.create({
         record: StudentGrades,
+        attributeQuery: [['target', { attributeQuery: ['credit'] }]],  // Required when callback reads fields
         callback: (relation) => ({
           weight: 1,
           value: relation.target.credit
@@ -529,6 +536,7 @@ const Student = Entity.create({
       defaultValue: () => 0,
       computation: WeightedSummation.create({
         record: StudentGrades,
+        attributeQuery: [['target', { attributeQuery: ['score', 'credit'] }]],  // Required when callback reads fields
         callback: (relation) => {
           // Only count subjects with score >= 60
           if (relation.target.score >= 60) {
@@ -568,6 +576,7 @@ const Project = Entity.create({
       defaultValue: () => false,
       computation: Every.create({
         record: ProjectTasks,
+        attributeQuery: [['target', { attributeQuery: ['status'] }]],  // Required when callback reads fields
         callback: (relation) => relation.target.status === 'completed'
       })
     })
@@ -605,6 +614,7 @@ const Project = Entity.create({
       defaultValue: () => false,
       computation: Any.create({
         record: ProjectMember,
+        attributeQuery: ['role'],  // Required when callback reads fields
         callback: (relation) => relation.role === 'admin'
       })
     })
@@ -639,6 +649,7 @@ const Order = Entity.create({
       defaultValue: () => false,
       computation: Every.create({
         record: OrderItems,
+        attributeQuery: [['target', { attributeQuery: ['quantity', 'stockQuantity'] }]],  // Required when callback reads fields
         callback: (relation) => {
           const item = relation.target;
           return item.quantity > 0 && item.stockQuantity >= item.quantity;
@@ -652,6 +663,7 @@ const Order = Entity.create({
       defaultValue: () => false,
       computation: Any.create({
         record: OrderItems,
+        attributeQuery: [['target', { attributeQuery: ['quantity', 'price'] }]],  // Required when callback reads fields
         callback: (relation) => {
           const item = relation.target;
           return (item.quantity * item.price) > 1000;
@@ -1118,71 +1130,75 @@ StateMachine is used for state transition-based computations, particularly suita
 
 ### Basic State Machine
 
-```javascript
-import { StateMachine } from 'interaqt';
-
-const Order = Entity.create({
-  name: 'Order',
-  properties: [
-    Property.create({ name: 'orderNumber', type: 'string' }),
-    Property.create({ 
-      name: 'status', 
-      type: 'string',
-      computation: new StateMachine({
-        states: ['pending', 'paid', 'shipped', 'delivered', 'cancelled'],
-        initialState: 'pending',
-        transitions: [
-          { from: 'pending', to: 'paid', condition: 'payment_received' },
-          { from: 'paid', to: 'shipped', condition: 'order_shipped' },
-          { from: 'shipped', to: 'delivered', condition: 'delivery_confirmed' },
-          { from: 'pending', to: 'cancelled', condition: 'order_cancelled' },
-          { from: 'paid', to: 'cancelled', condition: 'order_cancelled' }
-        ]
-      })
-    })
-  ]
-});
-```
+A StateMachine is declared from three parts: `StateNode` instances (the states), `StateTransfer` instances (the transitions), and an `initialState`. States are always object references, never strings.
 
-### Event-Based State Transitions
+Each `StateTransfer` declares:
+- `current` / `next`: the state nodes the transfer connects
+- `trigger`: a `RecordMutationEventPattern` (`{ recordName, type, keys?, record?, oldRecord? }`) matched against record mutation events — for interaction-triggered transitions, match the creation of the interaction's event record
+- `computeTarget` (required for property-level state machines): maps the matched event to the record(s) whose property should transition
 
 ```javascript
-// Define state transition events
-const PaymentReceived = Interaction.create({
-  name: 'PaymentReceived',
-  action: Action.create({
-    name: 'recordPayment',
-    payload: Payload.create({
-      items: [
-        PayloadItem.create({ name: 'orderId', base: Order, isRef: true }),
-        PayloadItem.create({ name: 'amount' }),
-        PayloadItem.create({ name: 'paymentMethod' })
-      ]
-    })
+import { StateMachine, StateNode, StateTransfer, InteractionEventEntity } from 'interaqt';
+
+// 1. Declare state nodes
+const pendingState = StateNode.create({ name: 'pending' });
+const paidState = StateNode.create({ name: 'paid' });
+const shippedState = StateNode.create({ name: 'shipped' });
+const deliveredState = StateNode.create({ name: 'delivered' });
+const cancelledState = StateNode.create({ name: 'cancelled' });
+
+// 2. Declare the interactions that drive the transitions
+const PayOrder = Interaction.create({
+  name: 'PayOrder',
+  action: Action.create({ name: 'payOrder' }),
+  payload: Payload.create({
+    items: [PayloadItem.create({ name: 'orderId', type: 'string', required: true })]
   })
 });
+// ... ShipOrder / ConfirmDelivery / CancelOrder declared the same way
 
-// State machine listens to these events and automatically transitions states
+// 3. Wire them together on the property
 const Order = Entity.create({
   name: 'Order',
   properties: [
+    Property.create({ name: 'orderNumber', type: 'string' }),
     Property.create({
       name: 'status',
       type: 'string',
-      computation: new StateMachine({
-        states: ['pending', 'paid', 'shipped', 'delivered'],
-        initialState: 'pending',
-        transitions: [
-          { 
-            from: 'pending', 
-            to: 'paid', 
-            on: 'PaymentReceived'  // Listen to interaction events
-          },
-          { 
-            from: 'paid', 
-            to: 'shipped', 
-            on: 'OrderShipped' 
-          }
+      computation: StateMachine.create({
+        states: [pendingState, paidState, shippedState, deliveredState, cancelledState],
+        initialState: pendingState,
+        transfers: [
+          StateTransfer.create({
+            current: pendingState,
+            next: paidState,
+            trigger: {
+              recordName: InteractionEventEntity.name,
+              type: 'create',
+              record: { interactionName: PayOrder.name }
+            },
+            computeTarget: (event) => ({ id: event.record.payload.orderId })
+          }),
+          StateTransfer.create({
+            current: paidState,
+            next: shippedState,
+            trigger: {
+              recordName: InteractionEventEntity.name,
+              type: 'create',
+              record: { interactionName: ShipOrder.name }
+            },
+            computeTarget: (event) => ({ id: event.record.payload.orderId })
+          }),
+          StateTransfer.create({
+            current: pendingState,
+            next: cancelledState,
+            trigger: {
+              recordName: InteractionEventEntity.name,
+              type: 'create',
+              record: { interactionName: CancelOrder.name }
+            },
+            computeTarget: (event) => ({ id: event.record.payload.orderId })
+          })
         ]
       })
     })
@@ -1190,48 +1206,62 @@ const Order = Entity.create({
 });
 ```
 
-### Conditional State Transitions
+### Data-Based State Transitions
+
+`trigger` matches **any** record mutation event, not just interaction events. This means state transitions can also be driven by data changes — for example, transition when a specific field of the host record is updated (`keys` uses subset semantics: the transfer fires when the update touched all the listed fields):
 
 ```javascript
-const LeaveRequest = Entity.create({
-  name: 'LeaveRequest',
-  properties: [
-    Property.create({ name: 'employeeId', type: 'string' }),
-    Property.create({ name: 'startDate', type: 'string' }),
-    Property.create({ name: 'endDate', type: 'string' }),
-    Property.create({ name: 'reason', type: 'string' }),
-    Property.create({
-      name: 'status',
-      type: 'string',
-      computation: new StateMachine({
-        states: ['draft', 'submitted', 'approved', 'rejected', 'cancelled'],
-        initialState: 'draft',
-        transitions: [
-          {
-            from: 'draft',
-            to: 'submitted',
-            on: 'SubmitRequest',
-            condition: (record) => record.reason && record.startDate && record.endDate
-          },
-          {
-            from: 'submitted',
-            to: 'approved',
-            on: 'ApproveRequest',
-            condition: (record, context) => context.user.role === 'manager'
-          },
-          {
-            from: 'submitted',
-            to: 'rejected',
-            on: 'RejectRequest',
-            condition: (record, context) => context.user.role === 'manager'
-          }
-        ]
+const draftState = StateNode.create({ name: 'draft' });
+const publishedState = StateNode.create({ name: 'published' });
+
+Property.create({
+  name: 'status',
+  type: 'string',
+  computation: StateMachine.create({
+    states: [draftState, publishedState],
+    initialState: draftState,
+    transfers: [
+      StateTransfer.create({
+        current: draftState,
+        next: publishedState,
+        // Fires when a Document update touches the `reviewed` field
+        trigger: { recordName: 'Document', type: 'update', keys: ['reviewed'] },
+        computeTarget: (event) => ({ id: event.oldRecord?.id ?? event.record?.id })
       })
-    })
-  ]
+    ]
+  })
 });
 ```
 
+Note: if several transfers share the same `current` state and their triggers match the same event but lead to different next states, the framework throws an "ambiguous transition" error — make the triggers mutually exclusive (e.g. via `record` / `keys` patterns).
+
+### Guarding Transitions
+
+There is no `condition` field on `StateTransfer`. Preconditions belong to the interaction layer (use `conditions` / `userAttributives` on the Interaction so unauthorized or invalid calls never produce an event), and fine-grained per-record filtering is expressed in `computeTarget` — return `null`/`undefined` (or an empty array) to skip the transition for records that should not transition:
+
+```javascript
+StateTransfer.create({
+  current: submittedState,
+  next: approvedState,
+  trigger: {
+    recordName: InteractionEventEntity.name,
+    type: 'create',
+    record: { interactionName: ApproveRequest.name }
+  },
+  computeTarget: async function (event) {
+    // `this` is the Controller: you can query before deciding the target
+    const request = await this.system.storage.findOne(
+      'LeaveRequest',
+      MatchExp.atom({ key: 'id', value: ['=', event.record.payload.requestId] }),
+      undefined,
+      ['id', 'reason', 'startDate', 'endDate']
+    );
+    if (!request?.reason || !request?.startDate || !request?.endDate) return null;
+    return { id: request.id };
+  }
+})
+```
+
 ### Dynamic Value Computation with StateNode
 
 StateMachine supports dynamic value computation through the `computeValue` function in StateNode. This allows you to compute and update property values during state transitions.
@@ -1263,8 +1293,12 @@ const EventEntity = Entity.create({
             // Self-transition: stays in the same state but triggers computeValue
             current: triggeredState,
             next: triggeredState,
-            trigger: TriggerEventInteraction,
-            computeTarget: (event) => ({ id: event.payload.eventId })
+            trigger: {
+              recordName: InteractionEventEntity.name,
+              type: 'create',
+              record: { interactionName: TriggerEventInteraction.name }
+            },
+            computeTarget: (event) => ({ id: event.record.payload.eventId })
           })
         ],
         initialState: triggeredState
@@ -1308,14 +1342,22 @@ const CounterEntity = Entity.create({
           StateTransfer.create({
             current: idleState,
             next: incrementingState,
-            trigger: IncrementInteraction,
-            computeTarget: (event) => ({ id: event.payload.counterId })
+            trigger: {
+              recordName: InteractionEventEntity.name,
+              type: 'create',
+              record: { interactionName: IncrementInteraction.name }
+            },
+            computeTarget: (event) => ({ id: event.record.payload.counterId })
           }),
           StateTransfer.create({
             current: incrementingState,
             next: idleState,
-            trigger: ResetInteraction,
-            computeTarget: (event) => ({ id: event.payload.counterId })
+            trigger: {
+              recordName: InteractionEventEntity.name,
+              type: 'create',
+              record: { interactionName: ResetInteraction.name }
+            },
+            computeTarget: (event) => ({ id: event.record.payload.counterId })
           })
         ],
         initialState: idleState
@@ -1369,20 +1411,32 @@ const TaskEntity = Entity.create({
           StateTransfer.create({
             current: newState,
             next: inProgressState,
-            trigger: StartTaskInteraction,
-            computeTarget: (event) => ({ id: event.payload.taskId })
+            trigger: {
+              recordName: InteractionEventEntity.name,
+              type: 'create',
+              record: { interactionName: StartTaskInteraction.name }
+            },
+            computeTarget: (event) => ({ id: event.record.payload.taskId })
           }),
           StateTransfer.create({
             current: inProgressState,
             next: completedState,
-            trigger: CompleteTaskInteraction,
-            computeTarget: (event) => ({ id: event.payload.taskId })
+            trigger: {
+              recordName: InteractionEventEntity.name,
+              type: 'create',
+              record: { interactionName: CompleteTaskInteraction.name }
+            },
+            computeTarget: (event) => ({ id: event.record.payload.taskId })
           }),
           StateTransfer.create({
             current: inProgressState,
             next: cancelledState,
-            trigger: CancelTaskInteraction,
-            computeTarget: (event) => ({ id: event.payload.taskId })
+            trigger: {
+              recordName: InteractionEventEntity.name,
+              type: 'create',
+              record: { interactionName: CancelTaskInteraction.name }
+            },
+            computeTarget: (event) => ({ id: event.record.payload.taskId })
           })
         ],
         initialState: newState
@@ -1858,6 +1912,7 @@ const Post = Entity.create({
       defaultValue: () => 0,
       computation: WeightedSummation.create({
         record: PostInteractions,
+        attributeQuery: [['target', { attributeQuery: ['type'] }]],  // Required when callback reads fields
         callback: (relation) => {
           const interaction = relation.target;
           switch (interaction.type) {
@@ -1889,6 +1944,7 @@ const Post = Entity.create({
       defaultValue: () => false,
       computation: Every.create({
         record: PostComments,
+        attributeQuery: [['target', { attributeQuery: ['status'] }]],  // Required when callback reads fields
         callback: (relation) => relation.target.status === 'approved'
       })
     })
@@ -1933,6 +1989,7 @@ Property.create({
   defaultValue: () => 0,
   computation: Count.create({
     record: User,
+    attributeQuery: ['status'],  // Required when callback reads fields
     callback: (user) => user.status === 'active'
   })
 });