ekms 9.6.1-beta.4 → 9.6.1-beta.5

package/common/dimension.instance.json

@@ -92,7 +92,7 @@
             "verb"
           ],
           "bridge": "{ ...next(operator), quantity: after[0], operator: operator, interpolate: [{ property: 'operator' }, { property: 'quantity' }] }",
-          "semantic": "async ({context, e, api, toArray, resolveResponse}) => {\n        const preferredUnits = api.getPreferredUnits(context.quantity)\n        if (!preferredUnits) {\n          return\n        }\n        const from = context.quantity;\n        const value = await e({ marker: 'convertToUnits', from, to: preferredUnits })\n        resolveResponse(context, value.evalue)\n      }"
+          "semantic": "async ({context, e, api, toArray, resolveResponse}) => {\n        const preferredUnits = await api.getPreferredUnits(context.quantity)\n        if (!preferredUnits) {\n          return\n        }\n        const from = context.quantity;\n        const value = await e({ marker: 'convertToUnits', from, to: preferredUnits })\n        resolveResponse(context, value.evalue)\n      }"
         },
         {
           "where": "/home/dev/code/theprogrammablemind/kms/common/dimension.js:214",

package/common/dimension.js

@@ -37,8 +37,8 @@ class API {
     this._objects = objects
   }
 
-  getPreferredUnits(quantity) {
-    const preferredUnits = this.args.mentions({
+  async getPreferredUnits(quantity) {
+    const preferredUnits = await this.args.mentions({
       context: { marker: 'unit' },
       condition: (unit) => {
         if (quantity.unit.marker == 'unitPerUnit') {
@@ -201,7 +201,7 @@ const config = {
       isA: ['verb'],
       bridge: "{ ...next(operator), quantity: after[0], operator: operator, interpolate: [{ property: 'operator' }, { property: 'quantity' }] }",
       semantic: async ({context, e, api, toArray, resolveResponse}) => {
-        const preferredUnits = api.getPreferredUnits(context.quantity)
+        const preferredUnits = await api.getPreferredUnits(context.quantity)
         if (!preferredUnits) {
           return
         }

package/common/drone.instance.json

@@ -333,7 +333,7 @@
             "1": "{ marker: 'drone' }"
           },
           "bridge": "{ ...next(operator), object: after[0], interpolate: [{ context: operator }, { property: 'object' }] }",
-          "semantic": "async ({mentioned, context, objects, api, say}) => {\n            await api.stop()\n            api.markCurrentPoint()\n          }"
+          "semantic": "async ({mentioned, context, objects, api, say}) => {\n            await api.stop()\n            await api.markCurrentPoint()\n          }"
         }
       ],
       "generators": [
@@ -353,7 +353,11 @@
         },
         {
           "match": "({context, contextHierarchy}) => {\n            if (!context.pullFromContext || !context.evaluate || contextHierarchy.under('doAction')) {\n              return false\n            }\n            \n            if (context.marker == 'path' || context.marker == 'this' || context.marker == 'that') {\n              return true\n            }\n          }",
-          "apply": "async ({context, fragments, stm, objects, mentioned, mentions, resolveEvaluate, _continue, contextHierarchy}) => {\n            // const points = mentions({ context: { marker: 'point' }, all: true })\n            const pathComponents = mentions({ context: { marker: 'pathComponent' }, all: true })\n            const path = (await fragments('path')).contexts()[0]\n            delete path.value\n            path.points = pathComponents.reverse()\n            await mentioned(path)\n            _continue()\n          }"
+          "apply": "async ({context, toArray, fragments, stm, objects, mentioned, mentions, resolveEvaluate, _continue, contextHierarchy}) => {\n            const pathComponents = toArray(await mentions({ context: { marker: 'pathComponent' }, all: true }))\n            const path = (await fragments('path')).contexts()[0]\n            delete path.value\n            path.points = pathComponents.reverse()\n            await mentioned(path)\n\n            _continue() // let the call pick the object out from the stm\n          }"
+        },
+        {
+          "match": "({context, contextHierarchy}) => {\n            if (!context.pullFromContext || !context.evaluate || !contextHierarchy.under('call') || context.notUnderCall) {\n              return false\n            }\n            \n            if (context.marker == 'point' || context.marker == 'ordinal') {\n              return true\n            }\n          }",
+          "apply": "async ({context, e, fragments, stm, toEValue, toArray, objects, mentioned, mentions, resolveEvaluate, _continue, contextHierarchy}) => {\n            const evaluated = await e({...context, notUnderCall: true})\n            const pointsContext = toEValue(evaluated)\n            const pathComponents = toArray(pointsContext)\n\n            const path = (await fragments('path')).contexts()[0]\n            delete path.value\n            path.points = pathComponents.reverse()\n            await mentioned(path)\n            resolveEvaluate(context, path)\n          }"
         },
         {
           "match": "({context}) => context.marker == 'thenTime'",
@@ -361,7 +365,7 @@
         },
         {
           "match": "({context}) => context.evaluate && ['start', 'end'].includes(context.marker) && context.objects && context.objects[1].marker == 'path'",
-          "apply": "async ({gp, s, context, objects, fragments, resolveEvaluate, api, mentions}) => {\n            const path = mentions({ context: context.objects[1] })\n            if (!path?.points) {\n              return\n            }\n            if (context.marker == 'start') {\n              resolveEvaluate(context, path?.points[0])\n            } else if (context.marker == 'end') {\n              resolveEvaluate(context, path?.points[path?.points.length-1])\n            }\n          }"
+          "apply": "async ({gp, s, context, objects, fragments, resolveEvaluate, api, mentions}) => {\n            const path = await mentions({ context: context.objects[1] })\n            if (!path?.points) {\n              return\n            }\n            if (context.marker == 'start') {\n              resolveEvaluate(context, path?.points[0])\n            } else if (context.marker == 'end') {\n              resolveEvaluate(context, path?.points[path?.points.length-1])\n            }\n          }"
         },
         {
           "match": "({context}) => context.marker == 'speed' && context.evaluate",
@@ -50265,6 +50269,7 @@
         {},
         {},
         {},
+        {},
         {}
       ]
     }

package/common/drone.js

@@ -310,7 +310,7 @@ class API {
     return this._objects.current.ordinal += 1
   }
 
-  currentPoint() {
+  async currentPoint() {
     const current = this._objects.current
     if (current.durationInSeconds) {
       // okay
@@ -318,7 +318,7 @@ class API {
       return null // in motion
     }
     const ordinal = this.currentOrdinal()
-    const lastPoint = this.args.mentions({ context: { marker: 'point' }, condition: (context) => context.ordinal == ordinal })
+    const lastPoint = await this.args.mentions({ context: { marker: 'point' }, condition: (context) => context.ordinal == ordinal })
     if (!current.startTime && !current.endTime && !current.durationInSeconds) {
       return lastPoint // did not move
     }
@@ -338,8 +338,8 @@ class API {
     return { x: xPrime, y: yPrime }
   }
 
-  markCurrentPoint() {
-    const point = this.currentPoint()
+  async markCurrentPoint() {
+    const point = await this.currentPoint()
     if (!point) {
       return
     }
@@ -405,14 +405,14 @@ class API {
       objects.current.durationInSeconds = distanceMeters / speed_meters_per_second
       await this.pause(objects.current.durationInSeconds, { batched: true })
       await this.stop({ batched: true })
-      this.markCurrentPoint()
+      await this.markCurrentPoint()
     }
 
     if (objects.current.path.length > 0) {
       if (objects.current.timeRepeats) {
         this.startRepeats(objects.current.timeRepeats)
       }
-      let currentPoint = this.args.mentions({ context: { marker: 'point' } }).point
+      let currentPoint = (await this.args.mentions({ context: { marker: 'point' } })).point
       this._objects.history.push({ marker: 'history', debug: 'doing path' })
       for (const pathComponent of objects.current.path) {
         if (pathComponent.marker == 'pause') {
@@ -544,7 +544,7 @@ class API {
     } else {
       ordinal = this.currentOrdinal() - 1
     }
-    const lastPoint = this.args.mentions({ context: { marker: 'point' }, condition: (context) => context.ordinal == ordinal })
+    const lastPoint = await this.args.mentions({ context: { marker: 'point' }, condition: (context) => context.ordinal == ordinal })
     if (!lastPoint) {
       this.args.say(`There is no previous point to go back to`)
       return
@@ -558,8 +558,8 @@ class API {
     const current = objects.current
     current.backAndForth = true
     const ordinal = this.currentOrdinal()
-    const currentPoint = this.args.mentions({ context: { marker: 'point' }, condition: (context) => context.ordinal == ordinal })
-    const lastPoint = this.args.mentions({ context: { marker: 'point' }, condition: (context) => context.ordinal == ordinal-1 })
+    const currentPoint = await this.args.mentions({ context: { marker: 'point' }, condition: (context) => context.ordinal == ordinal })
+    const lastPoint = await this.args.mentions({ context: { marker: 'point' }, condition: (context) => context.ordinal == ordinal-1 })
     current.path.push(lastPoint)
     current.path.push(currentPoint)
     objects.runCommand = true
@@ -1072,7 +1072,7 @@ const template = {
           bridge: "{ ...next(operator), object: after[0], interpolate: [{ context: operator }, { property: 'object' }] }",
           semantic: async ({mentioned, context, objects, api, say}) => {
             await api.stop()
-            api.markCurrentPoint()
+            await api.markCurrentPoint()
           }
         },
       ],
@@ -1108,9 +1108,8 @@ const template = {
               return true
             }
           },
-          apply: async ({context, fragments, stm, objects, mentioned, mentions, resolveEvaluate, _continue, contextHierarchy}) => {
-            // const points = mentions({ context: { marker: 'point' }, all: true })
-            const pathComponents = mentions({ context: { marker: 'pathComponent' }, all: true })
+          apply: async ({context, toArray, fragments, stm, objects, mentioned, mentions, resolveEvaluate, _continue, contextHierarchy}) => {
+            const pathComponents = toArray(await mentions({ context: { marker: 'pathComponent' }, all: true }))
             const path = (await fragments('path')).contexts()[0]
             delete path.value
             path.points = pathComponents.reverse()
@@ -1152,7 +1151,7 @@ const template = {
         {
           match: ({context}) => context.evaluate && ['start', 'end'].includes(context.marker) && context.objects && context.objects[1].marker == 'path',
           apply: async ({gp, s, context, objects, fragments, resolveEvaluate, api, mentions}) => {
-            const path = mentions({ context: context.objects[1] })
+            const path = await mentions({ context: context.objects[1] })
             if (!path?.points) {
               return
             }

package/common/drone_v1.instance.json

@@ -6,7 +6,7 @@
     "point is a concept",
     "points are nameable orderable and memorable",
     {
-      "apply": "(args) => {\n      askForCalibrationDistance(args)\n      askForEndTime(args)\n      askForStartTime(args)\n\n      expectDirection(args)\n      expectDistanceForCalibration(args)\n      expectCalibrationCompletion(args)\n\n      args.config.addSemantic({\n        match: ({context, isA}) => isA(context.marker, 'quantity') && isA(context.unit.marker, 'unitPerUnit'),\n        apply: async ({context, objects, api, fragments, e}) => {\n          // send a command to the drone\n          const instantiation = await fragments(\"quantity in meters per second\", { quantity: context })\n          const result = await e(instantiation)\n          const desired_speed = result.evalue.amount.evalue.evalue\n          const desired_power = objects.current.power * (desired_speed / objects.calibration.speed)\n          objects.runCommand = true\n          objects.current.power = desired_power \n        }\n      })\n\n      args.config.addSemantic({\n        match: ({context, objects, isA}) => objects.current.direction && objects.isCalibrated && context.marker == 'controlStart',\n        apply: ({context, objects, api}) => {\n          objects.runCommand = false  \n        }\n      })\n\n      args.config.addSemantic({\n        // match: ({context, objects, isA}) => objects.current.direction && objects.isCalibrated && (context.marker == 'controlEnd' || context.marker == 'controlBetween'),\n        match: ({context, objects, isA}) => objects.current.direction && objects.isCalibrated && context.marker == 'controlEnd',\n        apply: ({context, objects, api}) => {\n          // send a command to the drone\n          if (objects.runCommand) {\n            // debugger\n            api.sendCommand()\n          }\n        }\n      })\n    }"
+      "apply": "(args) => {\n      askForCalibrationDistance(args)\n      askForEndTime(args)\n      askForStartTime(args)\n\n      expectDirection(args)\n      expectDistanceForCalibration(args)\n      expectCalibrationCompletion(args)\n\n      args.config.addSemantic({\n        match: ({context, isA}) => isA(context.marker, 'quantity') && isA(context.unit.marker, 'unitPerUnit'),\n        apply: async ({context, objects, api, fragments, e}) => {\n          // send a command to the drone\n          const instantiation = await fragments(\"quantity in meters per second\", { quantity: context })\n          const result = await e(instantiation)\n          const desired_speed = result.evalue.amount.evalue.evalue\n          const desired_power = objects.current.power * (desired_speed / objects.calibration.speed)\n          objects.runCommand = true\n          objects.current.power = desired_power \n        }\n      })\n\n      args.config.addSemantic({\n        match: ({context, objects, isA}) => objects.current.direction && objects.isCalibrated && context.marker == 'controlStart',\n        apply: ({context, objects, api}) => {\n          objects.runCommand = false  \n        }\n      })\n\n      args.config.addSemantic({\n        // match: ({context, objects, isA}) => objects.current.direction && objects.isCalibrated && (context.marker == 'controlEnd' || context.marker == 'controlBetween'),\n        match: ({context, objects, isA}) => objects.current.direction && objects.isCalibrated && context.marker == 'controlEnd',\n        apply: async ({context, objects, api}) => {\n          // send a command to the drone\n          if (objects.runCommand) {\n            // debugger\n            await api.sendCommand()\n          }\n        }\n      })\n    }"
     },
     {
       "operators": [
@@ -62,7 +62,7 @@
             "1": "{ marker: 'drone' }"
           },
           "bridge": "{ ...next(operator), object: after[0], interpolate: [{ context: operator }, { property: 'object' }] }",
-          "semantic": "({mentioned, context, objects, api, say}) => {\n            if (!objects.calibration.startTime) {\n              return // ignore\n            }\n            if (objects.calibration.speed) {\n              /*\n              const stopTime = api.stop()\n              const ordinal = api.nextOrdinal()\n              const point = api.currentPoint()\n              mentioned({ marker: 'point', ordinal, point })\n              objects.current.ordinal = ordinal\n              */\n              api.stop()\n              api.markCurrentPoint()\n            } else {\n              const stopTime = api.stop()\n              objects.calibration.endTime = stopTime\n              objects.calibration.duration = (objects.calibration.endTime - objects.calibration.startTime)/1000\n            }\n          }"
+          "semantic": "async ({mentioned, context, objects, api, say}) => {\n            if (!objects.calibration.startTime) {\n              return // ignore\n            }\n            if (objects.calibration.speed) {\n              /*\n              const stopTime = api.stop()\n              const ordinal = api.nextOrdinal()\n              const point = api.currentPoint()\n              mentioned({ marker: 'point', ordinal, point })\n              objects.current.ordinal = ordinal\n              */\n              api.stop()\n              await api.markCurrentPoint()\n            } else {\n              const stopTime = api.stop()\n              objects.calibration.endTime = stopTime\n              objects.calibration.duration = (objects.calibration.endTime - objects.calibration.startTime)/1000\n            }\n          }"
         }
       ],
       "generators": [
@@ -17782,7 +17782,7 @@
       }
     },
     {
-      "apply": "(args) => {\n      askForCalibrationDistance(args)\n      askForEndTime(args)\n      askForStartTime(args)\n\n      expectDirection(args)\n      expectDistanceForCalibration(args)\n      expectCalibrationCompletion(args)\n\n      args.config.addSemantic({\n        match: ({context, isA}) => isA(context.marker, 'quantity') && isA(context.unit.marker, 'unitPerUnit'),\n        apply: async ({context, objects, api, fragments, e}) => {\n          // send a command to the drone\n          const instantiation = await fragments(\"quantity in meters per second\", { quantity: context })\n          const result = await e(instantiation)\n          const desired_speed = result.evalue.amount.evalue.evalue\n          const desired_power = objects.current.power * (desired_speed / objects.calibration.speed)\n          objects.runCommand = true\n          objects.current.power = desired_power \n        }\n      })\n\n      args.config.addSemantic({\n        match: ({context, objects, isA}) => objects.current.direction && objects.isCalibrated && context.marker == 'controlStart',\n        apply: ({context, objects, api}) => {\n          objects.runCommand = false  \n        }\n      })\n\n      args.config.addSemantic({\n        // match: ({context, objects, isA}) => objects.current.direction && objects.isCalibrated && (context.marker == 'controlEnd' || context.marker == 'controlBetween'),\n        match: ({context, objects, isA}) => objects.current.direction && objects.isCalibrated && context.marker == 'controlEnd',\n        apply: ({context, objects, api}) => {\n          // send a command to the drone\n          if (objects.runCommand) {\n            // debugger\n            api.sendCommand()\n          }\n        }\n      })\n    }"
+      "apply": "(args) => {\n      askForCalibrationDistance(args)\n      askForEndTime(args)\n      askForStartTime(args)\n\n      expectDirection(args)\n      expectDistanceForCalibration(args)\n      expectCalibrationCompletion(args)\n\n      args.config.addSemantic({\n        match: ({context, isA}) => isA(context.marker, 'quantity') && isA(context.unit.marker, 'unitPerUnit'),\n        apply: async ({context, objects, api, fragments, e}) => {\n          // send a command to the drone\n          const instantiation = await fragments(\"quantity in meters per second\", { quantity: context })\n          const result = await e(instantiation)\n          const desired_speed = result.evalue.amount.evalue.evalue\n          const desired_power = objects.current.power * (desired_speed / objects.calibration.speed)\n          objects.runCommand = true\n          objects.current.power = desired_power \n        }\n      })\n\n      args.config.addSemantic({\n        match: ({context, objects, isA}) => objects.current.direction && objects.isCalibrated && context.marker == 'controlStart',\n        apply: ({context, objects, api}) => {\n          objects.runCommand = false  \n        }\n      })\n\n      args.config.addSemantic({\n        // match: ({context, objects, isA}) => objects.current.direction && objects.isCalibrated && (context.marker == 'controlEnd' || context.marker == 'controlBetween'),\n        match: ({context, objects, isA}) => objects.current.direction && objects.isCalibrated && context.marker == 'controlEnd',\n        apply: async ({context, objects, api}) => {\n          // send a command to the drone\n          if (objects.runCommand) {\n            // debugger\n            await api.sendCommand()\n          }\n        }\n      })\n    }"
     },
     {
       "extraConfig": true,

package/common/drone_v1.js

@@ -141,12 +141,12 @@ class API {
     return this._objects.ordinal += 1
   }
 
-  currentPoint() {
+  async currentPoint() {
     if (!this._objects.current.endTime) {
       return null // in motion
     }
     const ordinal = this._objects.current.ordinal
-    const lastPoint = this.args.mentions({ context: { marker: 'point' }, condition: (context) => context.ordinal == ordinal })
+    const lastPoint = await this.args.mentions({ context: { marker: 'point' }, condition: (context) => context.ordinal == ordinal })
 
     const durationInSeconds = (this._objects.current.endTime - this._objects.current.startTime) / 1000
     const speedInMetersPerSecond = (this._objects.current.power / this._objects.calibration.power) * this._objects.calibration.speed
@@ -159,9 +159,9 @@ class API {
     return { x: xPrime, y: yPrime }
   }
 
-  markCurrentPoint() {
+  async markCurrentPoint() {
     const ordinal = this.nextOrdinal()
-    const point = this.currentPoint()
+    const point = await this.currentPoint()
     this.args.mentioned({ marker: 'point', ordinal, point })
     this._objects.current.ordinal = ordinal
     this._objects.current.endTime = null
@@ -186,17 +186,17 @@ class API {
     this.testDate = new Date(this.testDate.getTime() + (duration_in_seconds-1)*1000)
   }
 
-  sendCommand() {
-    const stopAtDistance = (distanceMeters) => {
+  async sendCommand() {
+    const stopAtDistance = async (distanceMeters) => {
       const speed_meters_per_second = this._objects.calibration.speed
       const duration_seconds = distanceMeters / speed_meters_per_second
       this.pause(duration_seconds)
       this.stop()
-      this.markCurrentPoint()
+      await this.markCurrentPoint()
     }
 
     if (this._objects.current.destination) {
-      const currentPoint = this.args.mentions({ context: { marker: 'point' } })
+      const currentPoint = await this.args.mentions({ context: { marker: 'point' } })
       const polar = cartesianToPolar(currentPoint.point, this._objects.current.destination.point)
       const destinationAngleInDegrees = radiansToDegrees(polar.angle)
       let angleDelta = destinationAngleInDegrees - this._objects.current.angleInDegrees
@@ -207,7 +207,7 @@ class API {
       }
       this.rotate(angleDelta)
       this.forward(this._objects.current.power)
-      stopAtDistance(polar.radius)
+      await stopAtDistance(polar.radius)
       return
     }
 
@@ -232,7 +232,7 @@ class API {
 
     if (command.distance) {
       const distanceMeters = command.distance
-      stopAtDistance(distanceMeters)
+      await stopAtDistance(distanceMeters)
     }
   }
 
@@ -456,11 +456,11 @@ const template = {
       args.config.addSemantic({
         // match: ({context, objects, isA}) => objects.current.direction && objects.isCalibrated && (context.marker == 'controlEnd' || context.marker == 'controlBetween'),
         match: ({context, objects, isA}) => objects.current.direction && objects.isCalibrated && context.marker == 'controlEnd',
-        apply: ({context, objects, api}) => {
+        apply: async ({context, objects, api}) => {
           // send a command to the drone
           if (objects.runCommand) {
             // debugger
-            api.sendCommand()
+            await api.sendCommand()
           }
         }
       })
@@ -529,7 +529,7 @@ const template = {
             1: "{ marker: 'drone' }",
           },
           bridge: "{ ...next(operator), object: after[0], interpolate: [{ context: operator }, { property: 'object' }] }",
-          semantic: ({mentioned, context, objects, api, say}) => {
+          semantic: async ({mentioned, context, objects, api, say}) => {
             if (!objects.calibration.startTime) {
               return // ignore
             }
@@ -542,7 +542,7 @@ const template = {
               objects.current.ordinal = ordinal
               */
               api.stop()
-              api.markCurrentPoint()
+              await api.markCurrentPoint()
             } else {
               const stopTime = api.stop()
               objects.calibration.endTime = stopTime

package/common/helpers/conjunction.js

@@ -1,6 +1,6 @@
 const { propertyToArray } = require('../helpers.js')
 
-function asList(context) {
+function asList(context, maybe=false) {
   if (Array.isArray(context)) {
     return {
       marker: 'list',
@@ -10,10 +10,14 @@ function asList(context) {
   } else if (context.marker === 'list') {
     return context
   }
-  return {
-    marker: 'list',
-    types: [context.marker],
-    value: [context]
+  if (maybe) {
+    return context
+  } else {
+    return {
+      marker: 'list',
+      types: [context.marker],
+      value: [context]
+    }
   }
 }
 

package/common/nameable.js

@@ -21,17 +21,6 @@ class API {
     this.args.config.addWord(name, { id: context.marker, initial: `{ value: "${name}", pullFromContext: true, nameable_named: true }` })
   }
 
-  get(type, name) {
-    return this.args.kms.stm.api.mentions({ 
-      context: type, 
-      condition: (context) => {
-        if (context.stm && context.stm.names) {
-          return context.stm.names.includes(name)
-        }
-      }
-    })
-  }
-
   getNamesByType(type) {
     const contexts = this.args.kms.stm.api.getByType(type)
     const names = new Set()

package/common/ordinals.js

@@ -31,6 +31,19 @@ const config = {
       bridge: "{ ...after[0], ordinal: before[0], modifiers: append(['ordinal'], after[0].modifiers) }" 
     },
   ],
+  semantics: [
+    {
+      where: where(),
+      match: ({context}) => context.marker == 'mentions' && context.evaluate,
+      apply: async ({callId, _continue, toList, context, kms, e, log, retry}) => {
+        if (context.args?.context?.ordinal?.marker == 'ordinal' && context.args?.context?.ordinal?.value == -1) {
+          const lastN = context.args.context.quantity.value || 1
+          context.args.lastN = lastN
+        }
+        _continue()
+      }
+    },
+  ],
   words: {
     "literals": {
       "first": [{"id": "ordinal", "initial": "{ value: 1, ordinal: true, instance: true }" }],

package/common/stm.js

@@ -1,6 +1,7 @@
 const { knowledgeModule, where, debug } = require('./runtime').theprogrammablemind
 const { defaultContextCheck } = require('./helpers')
 const helpers = require('./helpers')
+const helpers_conjunction = require('./helpers/conjunction')
 const articles = require('./articles')
 const evaluate = require('./evaluate')
 const stm_tests = require('./stm.test.json')
@@ -68,12 +69,8 @@ class API {
       concept.value = value
     }
     concept.fromSTM = true
-    if (!concept.stm) {
-      concept.stm = {}
-    }
-    if (!concept.stm.id) {
-      concept.stm.id = this.getId()
-    }
+    concept.stm ??= {}
+    concept.stm.id ??= this.getId()
     frameOfReference.mentioned = (frameOfReference.mentioned || []).filter( (context) => context.stm && context.stm.id != concept.stm.id )
     helpers.unshiftL(frameOfReference.mentioned, concept, this.maximumMentioned)
   }
@@ -275,17 +272,22 @@ const config = {
     },  
   ],
   semantics: [
+    {
+      where: where(),
+      match: ({context}) => context.marker == 'mentions' && context.evaluate,
+      apply: ({context, kms, toList, resolveEvaluate}) => {
+        resolveEvaluate(context, kms.stm.api.mentions(context.args))
+      }
+    },
     { 
       where: where(),
       notes: 'pull from context',
       // match: ({context}) => context.marker == 'it' && context.pullFromContext, // && context.value,
       match: ({context, callId}) => context.pullFromContext && !context.same, // && context.value,
-      apply: async ({callId, toList, context, kms, e, log, retry}) => {
-        if (context.ordinal?.marker == 'ordinal' && context.ordinal?.value == -1) {
-          const lastN = context.quantity.value || 1
-          context.value = toList(kms.stm.api.mentions({ context, lastN }))
-        } else {
-          context.value = kms.stm.api.mentions({ context })
+      apply: async ({callId, mentions, toList, context, kms, e, log, retry}) => {
+        context.value = (await mentions({ context }))
+        if (Array.isArray(context.value)) {
+          context.value = toList(context.value)
         }
 
         if (!context.value) {
@@ -307,12 +309,17 @@ const config = {
 }
 
 function initializer({config}) {
-  config.addArgs(({kms}) => ({
+  config.addArgs(({kms, e}) => ({
     mentioned: (args) => {
       kms.stm.api.mentioned(args)
     },
-    mentions: (args) => {
-      return kms.stm.api.mentions(args)
+    mentions: async (args) => {
+      const result = await e({ marker: 'mentions', args })
+      // evalue will return the argument if there is no evalue. dont want that for this case
+      if (!result.evalue) {
+        return
+      }
+      return helpers_conjunction.asList(helpers.toEValue(result), true)
     },
   }))
 }

package/package.json

@@ -386,8 +386,8 @@
     "scriptjs": "^2.5.9",
     "table": "^6.7.1",
     "uuid": "^9.0.0",
-    "theprogrammablemind": "9.6.1-beta.4"
+    "theprogrammablemind": "9.6.1-beta.5"
   },
-  "version": "9.6.1-beta.4",
+  "version": "9.6.1-beta.5",
   "license": "UNLICENSED"
 }