tpmkms_4wp 9.8.0-beta.3 → 9.8.0-beta.4

package/common/actions.instance.json

@@ -166,7 +166,7 @@
       },
       "semantics": [
         {
-          "match": "({context, isA, stack, namespaced}) => !context.pullFromContext && !context.evaluate && (isA(context.marker, 'action') || isA(context.marker, 'doAction')) && !namespaced.get('actions', context, 'logged')",
+          "match": "({context, isA, contextHierarchy, stack, namespaced}) => {\n        if (false) {\n          if (!context.pullFromContext && (isA(context.marker, 'action') || isA(context.marker, 'doAction')) && !namespaced.get('actions', context, 'logged')) {\n            if (context.evaluate) {\n              debugger\n              throw new Error(\"this is the error\")\n            }\n          }\n        }\n        // return !context.pullFromContext && !context.evaluate && (isA(context.marker, 'action') || isA(context.marker, 'doAction')) && !namespaced.get('actions', context, 'logged')\n        return !context.pullFromContext && !contextHierarchy.under('call') && (isA(context.marker, 'action') || isA(context.marker, 'doAction')) && !namespaced.get('actions', context, 'logged')\n      }",
           "apply": "async ({context, _continue, testLog, g, remember}) => {\n        remember(context)\n        await testLog(() => g(context))\n        _continue()\n      }"
         }
       ]

package/common/actions.js

@@ -147,7 +147,9 @@ const config = {
     {
       where: where(),
       priority: -1,
-      match: ({context, isA, stack, namespaced}) => !context.pullFromContext && !context.evaluate && (isA(context.marker, 'action') || isA(context.marker, 'doAction')) && !namespaced.get('actions', context, 'logged'),
+      match: ({context, isA, contextHierarchy, stack, namespaced}) => {
+        return !context.pullFromContext && !contextHierarchy.under('call') && (isA(context.marker, 'action') || isA(context.marker, 'doAction')) && !namespaced.get('actions', context, 'logged')
+      },
       apply: async ({context, _continue, testLog, g, remember}) => {
         remember(context)
         await testLog(() => g(context))

package/common/askfor.instance.json

@@ -64,7 +64,7 @@
             "ask"
           ],
           "bridge": "{\n            ...next(operator),\n            properties: after[0],\n            interpolate: [{ self: true }, { property: 'properties' }]\n          }",
-          "semantic": "async ({e, s, gp, objects, flatten, context, ask, fragments, toEValue}) => {\n            const argument = context.properties.argument\n            const getValue = (property) => async (args) => {\n              const value = toEValue(await e(property))\n              if (value.marker == 'answerNotKnown') {\n                return\n              }\n              return value\n            }\n\n            const setValue = (property) => async ({ context, namespaced, tag }) => {\n              const is = { marker: 'is', one: property, two: context }\n              namespaced.set('dialogs', is, 'allowHierarchy', false)\n              await s(is)\n            }\n\n            const properties = flattenInPlace(argument)\n            counter = 0\n            for (const property of properties.reverse()) {\n              counter += 1\n              const query = memoizeAsync(async () => await(gp(await fragments(\"what is the concept?\", { concept: property }))))\n              const compatible_types = property.compatible_types || [property.marker]\n              const matchr = ({context, isA}) => {\n                return !context.same && !context.evaluate && isA(context, compatible_types)\n              }\n              objects.askFor.push(property);\n              askForProperty({\n                ask,\n                tag: `ask#${counter}`,\n                getValue: getValue(property),\n                setValue: setValue(property),\n                query,\n                matchr,\n              })\n            }\n          }"
+          "semantic": "async ({e, s, gp, objects, flatten, context, ask, fragments, toEValue}) => {\n            const argument = context.properties.argument\n            const getValue = (property) => async (args) => {\n              const value = toEValue(await e(property))\n              if (value.marker === 'undefined') {\n                return\n              }\n              return value\n            }\n\n            const setValue = (property) => async ({ context, namespaced, tag }) => {\n              const is = { marker: 'is', one: property, two: context }\n              namespaced.set('dialogs', is, 'allowHierarchy', false)\n              await s(is)\n            }\n\n            const properties = flattenInPlace(argument)\n            counter = 0\n            for (const property of properties.reverse()) {\n              counter += 1\n              const query = memoizeAsync(async () => await(gp(await fragments(\"what is the concept?\", { concept: property }))))\n              const compatible_types = property.compatible_types || [property.marker]\n              const matchr = ({context, isA}) => {\n                return !context.same && isA(context, compatible_types)\n              }\n              objects.askFor.push(property);\n              askForProperty({\n                ask,\n                tag: `ask#${counter}`,\n                getValue: getValue(property),\n                setValue: setValue(property),\n                query,\n                matchr,\n              })\n            }\n          }"
         }
       ]
     },

package/common/askfor.js

@@ -118,7 +118,7 @@ const template = {
             const argument = context.properties.argument
             const getValue = (property) => async (args) => {
               const value = toEValue(await e(property))
-              if (value.marker == 'answerNotKnown') {
+              if (value.marker === 'undefined') {
                 return
               }
               return value
@@ -137,7 +137,7 @@ const template = {
               const query = memoizeAsync(async () => await(gp(await fragments("what is the concept?", { concept: property }))))
               const compatible_types = property.compatible_types || [property.marker]
               const matchr = ({context, isA}) => {
-                return !context.same && !context.evaluate && isA(context, compatible_types)
+                return !context.same && isA(context, compatible_types)
               }
               objects.askFor.push(property);
               askForProperty({

package/common/avatar.js

@@ -27,7 +27,7 @@ const config = {
     {
        where: where(),
        notes: "unknown answer default response for avatar",
-       match: ({context}) => context.marker == 'answerNotKnown',
+       match: ({context}) => context.marker === 'undefined',
        apply: ({context}) => `I don't know`,
     },
     {

package/common/dateTimeSelectors.instance.json

@@ -67,15 +67,15 @@
       ],
       "semantics": [
         {
-          "match": "({context, isA}) => context.evaluate && onOrIs('dayAfterDate', context)",
+          "match": "({context, isA}) => onOrIs('dayAfterDate', context)",
           "apply": "async ({context, isProcess, isTest, kms, isA, e}) => {\n            try {\n              const now = kms.time.api.now()\n              const date = afterOrIs('dayAfterDate', context)\n              const afterISO = (await e(date.after)).evalue\n              const day_ordinal = date.day.day_ordinal\n              const ordinal = date.day.ordinal.value\n              context.evalue = dateTimeSelectors_helpers.getNthWeekdayAfterDate(afterISO, day_ordinal, ordinal)\n            } catch ( e ) {\n              context.evalue = `Implement instatiate for this type of date, ${context.marker}. See the dateTimeSelectors KM ${where()}. ${e}`\n            }\n          }"
         },
         {
-          "match": "({context, isA}) => context.evaluate && onOrIs('dayOfMonth', context)",
+          "match": "({context, isA}) => onOrIs('dayOfMonth', context)",
           "apply": "({context, isProcess, isTest, kms, isA}) => {\n            try {\n              const now = kms.time.api.now()\n              const date = onOrIs('dayOfMonth', context)\n              context.evalue = dateTimeSelectors_helpers.getNthDayOfMonth(removeDatesSuffix(date.day.value), date.day.ordinal.value || 1, removeDatesSuffix(date.month.value), now)\n            } catch ( e ) {\n              context.evalue = `Implement instatiate for this type of date, ${context.marker}. See the dateTimeSelectors KM ${where()}. ${e}`\n            }\n          }"
         },
         {
-          "match": "({context, isA}) => {\n            if (!context.evaluate) {\n              return false\n            }\n            if (isA(context.marker, 'onDateValue_dates')) {\n              return true\n            }\n            if (isA(context.marker, 'dateTimeSelector')) {\n              return true\n            }\n          }",
+          "match": "({context, isA}) => {\n            if (isA(context.marker, 'onDateValue_dates')) {\n              return true\n            }\n            if (isA(context.marker, 'dateTimeSelector')) {\n              return true\n            }\n          }",
           "apply": "({context, isProcess, isTest, kms, isA}) => {\n            context.evalue = instantiate(kms, isA, isProcess || isTest || context.isTest, context)\n          }"
         }
       ],

package/common/dateTimeSelectors.js

@@ -94,7 +94,7 @@ const template = {
       ],
       semantics: [
         {
-          match: ({context, isA}) => context.evaluate && onOrIs('dayAfterDate', context),
+          match: ({context, isA}) => onOrIs('dayAfterDate', context),
           apply: async ({context, isProcess, isTest, kms, isA, e}) => {
             try {
               const now = kms.time.api.now()
@@ -109,7 +109,7 @@ const template = {
           },
         },
         {
-          match: ({context, isA}) => context.evaluate && onOrIs('dayOfMonth', context),
+          match: ({context, isA}) => onOrIs('dayOfMonth', context),
           apply: ({context, isProcess, isTest, kms, isA}) => {
             try {
               const now = kms.time.api.now()
@@ -122,9 +122,6 @@ const template = {
         },
         {
           match: ({context, isA}) => {
-            if (!context.evaluate) {
-              return false
-            }
             if (isA(context.marker, 'onDateValue_dates')) {
               return true
             }
@@ -156,7 +153,7 @@ knowledgeModule( {
     checks: {
       context: [
         // defaultContextCheck({ extra: ['date', 'time', 'response', 'after', 'day', 'month', 'year', 'evalue'] }),
-        defaultContextCheck({ extra: ['date', 'time', 'response', 'after', 'evalue'] }),
+        defaultContextCheck({ extra: ['date', 'time', 'after', 'evalue'] }),
       ],
     }
   },

package/common/dialogues.js

@@ -301,13 +301,13 @@ const config = {
     {
       where: where(),
       notes: "unknown answer default response",
-      match: ({context, namespaced}) => context.marker == 'answerNotKnown' && context.brief,
+      match: ({context, namespaced}) => context.marker === 'undefined' && context.brief,
       apply: ({context}) => `not known`,
     },
     {
       where: where(),
       notes: "unknown answer default response",
-      match: ({context}) => context.marker == 'answerNotKnown',
+      match: ({context}) => context.marker === 'undefined',
       apply: ({context}) => `that is not known`,
     },
     {
@@ -446,7 +446,7 @@ const config = {
       notes: 'x is y',
       match: ({context, hierarchy}) => hierarchy.isA(context.marker, 'is') && !context.evalue,
       apply: async ({isA, context, g, gp, debug, gr, callId}) => {
-        if ((context.two.evalue || {}).marker == 'answerNotKnown') {
+        if ((context.two.evalue || {}).marker === 'undefined') {
           return await g(context.two.evalue)
         }
 
@@ -454,8 +454,8 @@ const config = {
           return `${await gp(context.one)} ${isMany(context.one) || isMany(context.two) || isMany(context) ? "are" : "is"} ${await g(context.two)}`
         }
 
-        if (context.response) {
-          context = context.response
+        if (context.evalue) {
+          context = context.evalue
         }
 
         function hasFocus(property) {
@@ -575,6 +575,7 @@ const config = {
       apply: async ({context, s, log, km, objects, e, toEValue}) => {
         const one = context.one;
         const two = context.two;
+
         let query, value;
         if (one.query) {
           query = one;
@@ -591,7 +592,7 @@ const config = {
           return
         }
 
-        if (toEValue(instance)?.marker == 'answerNotKnown') {
+        if (toEValue(instance)?.marker === 'undefined') {
           context.evalue = instance
           context.isResponse = true
           return

package/common/dimension.instance.json

@@ -93,7 +93,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 = 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      }"
+          "semantic": "async ({context, e, api, toArray, resolveEvaluate}) => {\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        resolveEvaluate(context, value.evalue)\n      }"
         },
         {
           "where": "/home/dev/code/theprogrammablemind/kms/common/dimension.js:215",
@@ -224,8 +224,8 @@
     {
       "semantics": [
         {
-          "match": "({context, isA, debug}) => {\n            return context.evaluate && \n              context.marker == 'unify' && \n              context.terms.every((term) => isA(term, 'quantity')) &&\n              context.terms.every((term) => term.instance)\n          }",
-          "apply": "async ({context, e, unify, toEValue}) => {\n            const t1 = context.terms[0]\n            const t2 = context.terms[1]\n            if (t1.propertyType !== t2.propertyType) {\n              return\n            }\n            if (t1[t1.propertyType].marker !== t2[t2.propertyType].marker) {\n              return\n            }\n            const convert = await e({ marker: 'convertToUnits', from: t2, to: t1.unit })\n            const t2InT1Units = await toEValue(await toEValue(convert))\n            debug.counter('greg29')\n            if (!await unify(t1.amount, await t2InT1Units.amount)) {\n              // debugger\n            }\n            // debugger\n          }"
+          "match": "({context, isA, debug}) => {\n            return context.marker == 'unify' && \n              context.terms.every((term) => isA(term, 'quantity')) &&\n              context.terms.every((term) => term.instance)\n          }",
+          "apply": "async ({context, e, unify, toEValue}) => {\n            const t1 = context.terms[0]\n            const t2 = context.terms[1]\n            if (t1.propertyType !== t2.propertyType) {\n              return\n            }\n            if (t1[t1.propertyType].marker !== t2[t2.propertyType].marker) {\n              return\n            }\n            const convert = await e({ marker: 'convertToUnits', from: t2, to: t1.unit })\n            const t2InT1Units = await toEValue(await toEValue(convert))\n            // debug.coxunter('greg29')\n            if (!await unify(t1.amount, await t2InT1Units.amount)) {\n              // debugger\n            }\n            // debugger\n          }"
         }
       ]
     }

package/common/dimension.js

@@ -201,14 +201,14 @@ const config = {
       id: "preferredUnits",
       isA: ['verb'],
       bridge: "{ ...next(operator), quantity: after[0], operator: operator, interpolate: [{ property: 'operator' }, { property: 'quantity' }] }",
-      semantic: async ({context, e, api, toArray, resolveResponse}) => {
+      semantic: async ({context, e, api, toArray, resolveEvaluate}) => {
         const preferredUnits = await api.getPreferredUnits(context.quantity)
         if (!preferredUnits) {
           return
         }
         const from = context.quantity;
         const value = await e({ marker: 'convertToUnits', from, to: preferredUnits })
-        resolveResponse(context, value.evalue)
+        resolveEvaluate(context, value.evalue)
       }
     },
     { 
@@ -334,8 +334,7 @@ const template = {
       semantics: [
         {
           match: ({context, isA, debug}) => {
-            return context.evaluate && 
-              context.marker == 'unify' && 
+            return context.marker == 'unify' && 
               context.terms.every((term) => isA(term, 'quantity')) &&
               context.terms.every((term) => term.instance)
           },
@@ -350,7 +349,7 @@ const template = {
             }
             const convert = await e({ marker: 'convertToUnits', from: t2, to: t1.unit })
             const t2InT1Units = await toEValue(await toEValue(convert))
-            // debug.counter('greg29')
+            // debug.coxunter('greg29')
             if (!await unify(t1.amount, await t2InT1Units.amount)) {
               // debugger
             }

package/common/drone.instance.json

@@ -284,7 +284,7 @@
             },
             "path"
           ],
-          "semantic": "async ({context, g, e, toArray, fragments, toEValue, toFinalValue, recall, objects, verbatim}) => {\n            const paths = toArray(context.path)\n            for (const context_path of paths) {\n              const evaluated = await(e(context_path))\n              const path = toEValue(evaluated)\n              if (path.marker == 'answerNotKnown') {\n                verbatim(`${await g(context_path)} is not a known path`)\n                continue\n              }\n           \n              objects.current.path.push({ message: await g(context) })\n\n              // TODO put this in a common place for use by do+patrol \n\n              // ordinal to pause time in seconds \n              const pauseTimeInSeconds = {}\n              if (context.pause) {\n                const timeAtPoints = toArray(context.pause.timeAtPoint)\n                for (const timeAtPoint of timeAtPoints) {\n                  const instantiation = await fragments(\"quantity in seconds\", { quantity: timeAtPoint.time })\n                  const result = await e(instantiation)\n                  const seconds = toFinalValue(toFinalValue(result).amount)\n\n                  const points = await recall({ context: timeAtPoint.point.point, frameOfReference: path })\n                  for (const point of toArray(points)) {\n                    pauseTimeInSeconds[point.ordinal] = seconds\n                  }\n                }\n              }\n\n              let skipPoints = []\n              if (context.skip) {\n                skipPoints = toArray(await recall({ context: context.skip.points, frameOfReference: path }))\n              }\n\n              // get to the start of the patrol  \n              objects.current.path.push(path.points[0])\n              objects.current.path.push({ aimOnly: true, ...path.points[1] })\n              objects.current.path.push({ repeatStart: true })\n              for (const point of path.points) {\n                if (skipPoints.find((skipPoint) => skipPoint.ordinal == point.ordinal)) {\n                  continue\n                }\n                objects.current.path.push(point)\n                if (pauseTimeInSeconds[point.ordinal]) {\n                  objects.current.path.push({ marker: 'pause', pauseSeconds: pauseTimeInSeconds[point.ordinal] })\n                }\n              }\n              if (context.repeats) {\n                objects.current.timeRepeats = toFinalValue(context.repeats.repeats)\n              }\n              // if the patrol does not start and end at the same spot then \n              // go back to the start along the same path\n\n\n              // if the start is not the end of the patrol then go backwards along the patrol\n              if (JSON.stringify(path.points[0].point) !== JSON.stringify(path.points[path.points.length-1].point)) {\n                for (const point of [...path.points].reverse().slice(1)) {\n                  if (skipPoints.find((skipPoint) => skipPoint.ordinal == point.ordinal)) {\n                    continue\n                  }\n                  objects.current.path.push(point)\n                  if (pauseTimeInSeconds[point.ordinal]) {\n                    objects.current.path.push({ marker: 'pause', pauseSeconds: pauseTimeInSeconds[point.ordinal] })\n                  }\n                }\n\n                const secondPoint = path.points[1]\n                objects.current.path.push({ ...secondPoint, aimOnly: true })\n              }\n            }\n            objects.runCommand = true\n          }"
+          "semantic": "async ({context, g, e, toArray, fragments, toEValue, toFinalValue, recall, objects, verbatim}) => {\n            const paths = toArray(context.path)\n            for (const context_path of paths) {\n              const evaluated = await(e(context_path))\n              const path = toEValue(evaluated)\n              if (path.marker === 'undefined') {\n                verbatim(`${await g(context_path)} is not a known path`)\n                continue\n              }\n           \n              objects.current.path.push({ message: await g(context) })\n\n              // TODO put this in a common place for use by do+patrol \n\n              // ordinal to pause time in seconds \n              const pauseTimeInSeconds = {}\n              if (context.pause) {\n                const timeAtPoints = toArray(context.pause.timeAtPoint)\n                for (const timeAtPoint of timeAtPoints) {\n                  const instantiation = await fragments(\"quantity in seconds\", { quantity: timeAtPoint.time })\n                  const result = await e(instantiation)\n                  const seconds = toFinalValue(toFinalValue(result).amount)\n\n                  const points = await recall({ context: timeAtPoint.point.point, frameOfReference: path })\n                  for (const point of toArray(points)) {\n                    pauseTimeInSeconds[point.ordinal] = seconds\n                  }\n                }\n              }\n\n              let skipPoints = []\n              if (context.skip) {\n                skipPoints = toArray(await recall({ context: context.skip.points, frameOfReference: path }))\n              }\n\n              // get to the start of the patrol  \n              objects.current.path.push(path.points[0])\n              objects.current.path.push({ aimOnly: true, ...path.points[1] })\n              objects.current.path.push({ repeatStart: true })\n              for (const point of path.points) {\n                if (skipPoints.find((skipPoint) => skipPoint.ordinal == point.ordinal)) {\n                  continue\n                }\n                objects.current.path.push(point)\n                if (pauseTimeInSeconds[point.ordinal]) {\n                  objects.current.path.push({ marker: 'pause', pauseSeconds: pauseTimeInSeconds[point.ordinal] })\n                }\n              }\n              if (context.repeats) {\n                objects.current.timeRepeats = toFinalValue(context.repeats.repeats)\n              }\n              // if the patrol does not start and end at the same spot then \n              // go back to the start along the same path\n\n\n              // if the start is not the end of the patrol then go backwards along the patrol\n              if (JSON.stringify(path.points[0].point) !== JSON.stringify(path.points[path.points.length-1].point)) {\n                for (const point of [...path.points].reverse().slice(1)) {\n                  if (skipPoints.find((skipPoint) => skipPoint.ordinal == point.ordinal)) {\n                    continue\n                  }\n                  objects.current.path.push(point)\n                  if (pauseTimeInSeconds[point.ordinal]) {\n                    objects.current.path.push({ marker: 'pause', pauseSeconds: pauseTimeInSeconds[point.ordinal] })\n                  }\n                }\n\n                const secondPoint = path.points[1]\n                objects.current.path.push({ ...secondPoint, aimOnly: true })\n              }\n            }\n            objects.runCommand = true\n          }"
         },
         {
           "id": "lift",
@@ -826,28 +826,28 @@
           "apply": "async ({context, fragments, e, s, toEValue, toFinalValue, namespaced, objects}) => {\n            const updated = { ...context, marker: 'patrol', path: context.action }\n            namespaced.set('actions', updated, 'logged', true)\n            await s(updated)\n            // await s({ ...context, marker: 'patrol', path: context.action })\n          }"
         },
         {
-          "match": "({context, contextHierarchy}) => {\n            if (!context.pullFromContext || !context.evaluate || contextHierarchy.under(['doAction', 'evaluate', 'patrol']) || context.isInstance) {\n              return false\n            }\n            \n            if (context.marker == 'path' || context.marker == 'this' || context.marker == 'that') {\n              return true\n            }\n          }",
+          "match": "({context, contextHierarchy}) => {\n            if (!context.pullFromContext || contextHierarchy.under(['doAction', 'evaluate', 'patrol']) || context.isInstance) {\n              return false\n            }\n            \n            if (context.marker == 'path' || context.marker == 'this' || context.marker == 'that') {\n              return true\n            }\n          }",
           "apply": "async ({context, frameOfReference, toArray, fragments, objects, remember, recall, resolveEvaluate, _continue, contextHierarchy}) => {\n            const pathComponents = toArray(await recall({ \n                                      context: { marker: 'pathComponent' }, \n                                      all: true,\n                                      stopCondition: (context) => context.marker == 'startPath',\n                                   }))\n            const path = (await fragments('path')).contexts()[0]\n            delete path.value\n            path.isInstance = true\n            path.points = pathComponents.reverse()\n            frameOfReference(path, { mentioned: 'points', reversed: true })\n            await remember(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          }",
+          "match": "({context, contextHierarchy}) => {\n            if (!context.pullFromContext || !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 ({frameOfReference, context, e, fragments, stm, toEValue, toArray, objects, remember, recall, 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.isInstance = true\n            path.points = [...pathComponents]\n            frameOfReference(path, { mentioned: 'points', reversed: true })\n            await remember(path)\n            resolveEvaluate(context, path)\n          }"
         },
         {
-          "match": "({context}) => context.evaluate && ['start', 'end'].includes(context.marker) && context.objects && context.objects[1].marker == 'path'",
+          "match": "({context}) => ['start', 'end'].includes(context.marker) && context.objects && context.objects[1].marker == 'path'",
           "apply": "async ({gp, s, context, objects, fragments, resolveEvaluate, api, recall}) => {\n            const path = await recall({ 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, contextHierarchy}) => \n              context.evaluate && \n              ['start', 'end', 'point'].includes(context.marker) && \n              !context.propertyOf && \n              contextHierarchy.under('go') &&\n              !contextHierarchy.under('call')",
+          "match": "({context, contextHierarchy}) => \n              ['start', 'end', 'point'].includes(context.marker) && \n              !context.propertyOf && \n              contextHierarchy.under('go') &&\n              !contextHierarchy.under('call')",
           "apply": "async ({gp, s, toArray, context, objects, fragments, resolveEvaluate, api, recall}) => {\n            const path = await recall({ context: { marker: 'path' } })\n            if (!path?.points) {\n              return\n            }\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            } else {\n              const points = await recall({ context, frameOfReference: path })\n              resolveEvaluate(context, toArray(points)[0])\n            }\n          }"
         },
         {
-          "match": "({context}) => {\n            // from stm lookup\n            if (context.marker == 'mentions' && context.evaluate && context.args.context.marker == 'speed') {\n              return true\n            }\n            // from property directly\n            if (context.marker == 'speed' && context.evaluate) {\n              return true\n            }\n          }",
-          "apply": "async ({gp, s, context, objects, fragments, resolveEvaluate, api}) => {\n            let return_context = context\n            if (context.marker == 'speed') {\n              // okay\n            } else {\n              // stm lookup\n              return_context = context\n              context = context.args.context\n            }\n            let value = objects.current.speed\n            if (context.condition) {\n              if (['highest', 'maximum'].includes(context.condition.marker)) {\n                value = api.maximumSpeedDrone()\n              } else if (['lowest', 'minimum'].includes(context.condition.marker)) {\n                value = api.minimumSpeedDrone()\n              }\n            }\n            const speed = await fragments(\"number meters per second\", { number: { marker: 'integer', value, word: undefined} })\n            const preferred = await s({ marker: 'preferredUnits', quantity: speed }) \n            resolveEvaluate(return_context, preferred.response || speed)\n          }"
+          "match": "({context}) => {\n            // from stm lookup\n            if (context.marker == 'mentions' && context.args.context.marker == 'speed') {\n              return true\n            }\n            // from property directly\n            if (context.marker == 'speed') {\n              return true\n            }\n          }",
+          "apply": "async ({gp, s, context, objects, fragments, resolveEvaluate, api}) => {\n            let return_context = context\n            if (context.marker == 'speed') {\n              // okay\n            } else {\n              // stm lookup\n              return_context = context\n              context = context.args.context\n            }\n            let value = objects.current.speed\n            if (context.condition) {\n              if (['highest', 'maximum'].includes(context.condition.marker)) {\n                value = api.maximumSpeedDrone()\n              } else if (['lowest', 'minimum'].includes(context.condition.marker)) {\n                value = api.minimumSpeedDrone()\n              }\n            }\n            const speed = await fragments(\"number meters per second\", { number: { marker: 'integer', value, word: undefined} })\n            const preferred = await s({ marker: 'preferredUnits', quantity: speed }) \n            resolveEvaluate(return_context, preferred.evalue || speed)\n          }"
         },
         {
-          "match": "({context}) => {\n            if (context.marker == 'mentions' && context.evaluate && ['direction', 'drone_direction'].includes(context.args.context.marker)) {\n              return true\n            }\n            if (['direction', 'drone_direction'].includes(context.marker) && context.evaluate) {\n              return true\n            }\n          }",
-          "apply": "async ({gp, s, context, objects, fragments, resolveEvaluate, api}) => {\n            const value = objects.current.angleInRadians\n            const fi = await fragments(\"number radians\")\n            const direction = await fi.instantiate([\n              { \n                match: ({path, pathEquals}) => pathEquals(path, ['0', 'amount']),\n                apply: ({context}) => {\n                  Object.assign(context, { marker: 'number', value: value, word: undefined })\n                }\n              }\n            ])\n            const preferred = await s({ marker: 'preferredUnits', quantity: direction }) \n            resolveEvaluate(context, preferred.response || direction)\n          }"
+          "match": "({context}) => {\n            if (context.marker == 'mentions' && ['direction', 'drone_direction'].includes(context.args.context.marker)) {\n              return true\n            }\n            if (['direction', 'drone_direction'].includes(context.marker)) {\n              return true\n            }\n          }",
+          "apply": "async ({gp, s, context, objects, fragments, resolveEvaluate, api}) => {\n            const value = objects.current.angleInRadians\n            const fi = await fragments(\"number radians\")\n            const direction = await fi.instantiate([\n              { \n                match: ({path, pathEquals}) => pathEquals(path, ['0', 'amount']),\n                apply: ({context}) => {\n                  Object.assign(context, { marker: 'number', value: value, word: undefined })\n                }\n              }\n            ])\n            const preferred = await s({ marker: 'preferredUnits', quantity: direction }) \n            resolveEvaluate(context, preferred.evalue || direction)\n          }"
         },
         {
           "match": "({context}) => context.marker == 'timeRepeats'",
@@ -10782,16 +10782,16 @@
         },
         {},
         {
-          "where": "/home/dev/code/theprogrammablemind/kms/common/drone.js:1438"
+          "where": "/home/dev/code/theprogrammablemind/kms/common/drone.js:1437"
         },
         {
-          "where": "/home/dev/code/theprogrammablemind/kms/common/drone.js:1472"
+          "where": "/home/dev/code/theprogrammablemind/kms/common/drone.js:1471"
         },
         {
-          "where": "/home/dev/code/theprogrammablemind/kms/common/drone.js:1498"
+          "where": "/home/dev/code/theprogrammablemind/kms/common/drone.js:1497"
         },
         {
-          "where": "/home/dev/code/theprogrammablemind/kms/common/drone.js:1505"
+          "where": "/home/dev/code/theprogrammablemind/kms/common/drone.js:1504"
         }
       ]
     }

package/common/drone.js

@@ -228,7 +228,7 @@ https://www.amazon.ca/Freenove-Raspberry-Tracking-Avoidance-Ultrasonic/dp/B0BNDQ
 
 function expectDirection(args) {
   args.config.addSemantic({
-    match: ({context, isA}) => isA(context.marker, 'direction') && !context.evaluate,
+    match: ({context, isA}) => isA(context.marker, 'direction'),
     apply: ({objects, context}) => {
       objects.runCommand = true
       objects.current.direction = context.marker
@@ -992,7 +992,7 @@ const template = {
             for (const context_path of paths) {
               const evaluated = await(e(context_path))
               const path = toEValue(evaluated)
-              if (path.marker == 'answerNotKnown') {
+              if (path.marker === 'undefined') {
                 verbatim(`${await g(context_path)} is not a known path`)
                 continue
               }
@@ -1337,7 +1337,7 @@ const template = {
         {
           where: where(),
           match: ({context, contextHierarchy}) => {
-            if (!context.pullFromContext || !context.evaluate || contextHierarchy.under(['doAction', 'evaluate', 'patrol']) || context.isInstance) {
+            if (!context.pullFromContext || contextHierarchy.under(['doAction', 'evaluate', 'patrol']) || context.isInstance) {
               return false
             }
             
@@ -1364,7 +1364,7 @@ const template = {
         {
           where: where(),
           match: ({context, contextHierarchy}) => {
-            if (!context.pullFromContext || !context.evaluate || !contextHierarchy.under('call') || context.notUnderCall) {
+            if (!context.pullFromContext || !contextHierarchy.under('call') || context.notUnderCall) {
               return false
             }
             
@@ -1398,7 +1398,7 @@ const template = {
         */
         {
           where: where(),
-          match: ({context}) => context.evaluate && ['start', 'end'].includes(context.marker) && context.objects && context.objects[1].marker == 'path',
+          match: ({context}) => ['start', 'end'].includes(context.marker) && context.objects && context.objects[1].marker == 'path',
           apply: async ({gp, s, context, objects, fragments, resolveEvaluate, api, recall}) => {
             const path = await recall({ context: context.objects[1] })
             if (!path?.points) {
@@ -1413,7 +1413,6 @@ const template = {
         },
         {
           match: ({context, contextHierarchy}) => 
-              context.evaluate && 
               ['start', 'end', 'point'].includes(context.marker) && 
               !context.propertyOf && 
               contextHierarchy.under('go') &&
@@ -1438,11 +1437,11 @@ const template = {
           where: where(),
           match: ({context}) => {
             // from stm lookup
-            if (context.marker == 'mentions' && context.evaluate && context.args.context.marker == 'speed') {
+            if (context.marker == 'mentions' && context.args.context.marker == 'speed') {
               return true
             }
             // from property directly
-            if (context.marker == 'speed' && context.evaluate) {
+            if (context.marker == 'speed') {
               return true
             }
           },
@@ -1465,17 +1464,17 @@ const template = {
             }
             const speed = await fragments("number meters per second", { number: { marker: 'integer', value, word: undefined} })
             const preferred = await s({ marker: 'preferredUnits', quantity: speed }) 
-            resolveEvaluate(return_context, preferred.response || speed)
+            resolveEvaluate(return_context, preferred.evalue || speed)
           }
         },
         {
           where: where(),
           // recallOverride(context(), frameOfReference())
           match: ({context}) => {
-            if (context.marker == 'mentions' && context.evaluate && ['direction', 'drone_direction'].includes(context.args.context.marker)) {
+            if (context.marker == 'mentions' && ['direction', 'drone_direction'].includes(context.args.context.marker)) {
               return true
             }
-            if (['direction', 'drone_direction'].includes(context.marker) && context.evaluate) {
+            if (['direction', 'drone_direction'].includes(context.marker)) {
               return true
             }
           },
@@ -1491,7 +1490,7 @@ const template = {
               }
             ])
             const preferred = await s({ marker: 'preferredUnits', quantity: direction }) 
-            resolveEvaluate(context, preferred.response || direction)
+            resolveEvaluate(context, preferred.evalue || direction)
           }
         },
         {

package/common/evaluate.js

@@ -25,8 +25,8 @@ const config = {
       after: ['verb'],
       enhanced_associations: false,
       bridge: "{ ...next(operator), postModifiers: ['value'], value: after[0] }",
-      semantic: async ({context, e, resolveResponse}) => {
-        resolveResponse(context, (await e(context.value)).evalue)
+      semantic: async ({context, e, resolveEvaluate}) => {
+        resolveEvaluate(context, (await e(context.value)).evalue)
       }
     }
   ],
@@ -34,20 +34,14 @@ const config = {
 
 function initializer({objects, config, isModule}) {
   config.addArgs(({config, api, toList, isA}) => ({
-    resolveResponse: (context, value) => {
-      context.response = value || { marker: 'answerNotKnown' }
-      if (context.response) {
-        context.isResponse = true
-      }
-    },
     resolveEvaluate: (context, value) => {
-      if (value == undefined) {
-        throw new Error("The arguments are context and the value. The value may not be undefined.")
-      }
       if (Array.isArray(value)) {
         value = toList(value)
       }
-      context.evalue = value
+      context.evalue = value || { marker: 'undefined' }
+      if (context.evalue) {
+        context.isResponse = true
+      }
     },
   }))
 }

package/common/formulas.instance.json

@@ -45,7 +45,7 @@
           "convolution": true,
           "bridge": "{ number: before[0].number, ...next(operator), what: before[0], equality: after[0], variable: after[1] }",
           "generatorp": "async ({context, g}) => `${await g(context.what)} ${await g(context.equality)} ${await g(context.variable)}`",
-          "evaluator": "({context, api, objects, verbatim}) => {\n        const formulas = api.gets(context.variable).map((f) => { return { ...f.equality, paraphrase: true } })\n        if (formulas.length > 0) {\n          context.evalue = { marker: 'list', value: formulas }\n        } else {\n          context.evalue = { marker: 'answerNotKnown' }\n        }\n      }"
+          "evaluator": "({context, api, objects, verbatim}) => {\n        const formulas = api.gets(context.variable).map((f) => { return { ...f.equality, paraphrase: true } })\n        if (formulas.length > 0) {\n          context.evalue = { marker: 'list', value: formulas }\n        } else {\n          context.evalue = { marker: 'undefined' }\n        }\n      }"
         },
         {
           "where": "/home/dev/code/theprogrammablemind/kms/common/formulas.js:100",
@@ -53,7 +53,7 @@
           "enhanced_associations": false,
           "bridge": "{ ...next(operator), equality: after[0], variable: after[2] }",
           "generatorp": "async ({context, gp}) => `${context.word} ${await gp(context.equality)} for ${await gp(context.variable)}`",
-          "semantic": "async ({api, context, fragments}) => {\n        try {\n          context.response = await api.solveFor(context.equality, context.variable)\n          context.isResponse = true\n          context.value = null\n        } catch( e ) {\n        }\n        if (!context.response) {\n          // TODO some KM for talking to the user wrt brief+avatar\n          context.verbatim = `Solving failed`\n        }\n      }"
+          "semantic": "async ({api, context, fragments}) => {\n        try {\n          context.evalue = await api.solveFor(context.equality, context.variable)\n          context.isResponse = true\n          context.value = null\n        } catch( e ) {\n        }\n        if (!context.evalue) {\n          // TODO some KM for talking to the user wrt brief+avatar\n          context.verbatim = `Solving failed`\n        }\n      }"
         },
         {
           "id": "forVariable",

package/common/formulas.js

@@ -92,7 +92,7 @@ const config = {
         if (formulas.length > 0) {
           context.evalue = { marker: 'list', value: formulas }
         } else {
-          context.evalue = { marker: 'answerNotKnown' }
+          context.evalue = { marker: 'undefined' }
         }
       }
     },
@@ -104,12 +104,12 @@ const config = {
       generatorp: async ({context, gp}) => `${context.word} ${await gp(context.equality)} for ${await gp(context.variable)}`,
       semantic: async ({api, context, fragments}) => {
         try {
-          context.response = await api.solveFor(context.equality, context.variable)
+          context.evalue = await api.solveFor(context.equality, context.variable)
           context.isResponse = true
           context.value = null
         } catch( e ) {
         }
-        if (!context.response) {
+        if (!context.evalue) {
           // TODO some KM for talking to the user wrt brief+avatar
           context.verbatim = `Solving failed`
         }

package/common/gdefaults.js

@@ -29,8 +29,8 @@ const config = {
      */
     {
       where: where(),
-      match: ({context}) => context.isResponse && context.response,
-      apply: ({context, gr}) => gr(context.response),
+      match: ({context}) => context.isResponse && context.evalue,
+      apply: ({context, gr}) => gr(context.evalue),
     },
 
     {
@@ -269,7 +269,7 @@ const config = {
 
     {
       where: where(),
-      match: ({context}) => context.marker == 'answerNotKnown',
+      match: ({context}) => context.marker === 'undefined',
       apply: ({context}) => 'That is not known',
     },
 

package/common/hierarchy.js

@@ -114,7 +114,7 @@ const config = {
       // types of job           what are the types of animals -> next one
       notes: 'type of pikachu',  // the types of type is the next one
       where: where(),
-      match: ({context}) => context.marker == 'type' && context.evaluate && context.objects[context.objects.length-1].number == 'one' && pluralize.isSingular(context.objects[0].word),
+      match: ({context}) => context.marker == 'type' && context.objects[context.objects.length-1].number == 'one' && pluralize.isSingular(context.objects[0].word),
       apply: async ({context, hierarchy, objects, e, gs, km, log}) => {
         const concept = context.objects[0];
         const value = context.objects[1];
@@ -297,7 +297,7 @@ const config = {
       // types of job
       notes: 'types of type', // what are the types of animals
       where: where(),
-      match: ({context}) => context.marker == 'type' && context.evaluate && context.objects,
+      match: ({context}) => context.marker == 'type' && context.objects,
       apply: ({context, objects, km, isA}) => {
         const api = km('properties').api
         const conceptApi = km('concept').api

package/common/meta.js

@@ -1,4 +1,4 @@
-const { knowledgeModule, ensureTestFile, where, unflatten, flattens } = require('./runtime').theprogrammablemind
+const { knowledgeModule, ensureTestFile, where, unflatten, flattens, debug } = require('./runtime').theprogrammablemind
 const { defaultContextCheck } = require('./helpers')
 const _ = require('lodash')
 const gdefaults = require('./gdefaults.js')
@@ -367,6 +367,7 @@ const config = {
                 TO.query = context.query
               } else {
                 TO.evaluate = context.evaluate
+                TO.metaDefinition = true
               }
               TO[`disable${uuid}`] = true
               toPrime = await s(TO)

package/common/nameable.js

@@ -92,7 +92,7 @@ const config = {
       isA: ['verb'],
       bridge: "{ ...next(operator), type: after[0] }",
       semantic: async ({context, api}) => {
-        context.response = api.getNamesByType(context.type.value).join(" ")
+        context.evalue = api.getNamesByType(context.type.value).join(" ")
         context.isResponse = true
       }
     },
@@ -156,7 +156,7 @@ const config = {
   semantics: [
     {
       where: where(),
-      match: ({context}) => context.marker == 'mentions' && context.evaluate && context.args?.context?.nameable_named,
+      match: ({context}) => context.marker == 'mentions' && context.args?.context?.nameable_named,
       apply: async ({callId, _continue, toList, context, kms, e, log, retry}) => {
         context.args.condition ??= () => true
         const oldCondition = context.args.condition

package/common/ordinals.js

@@ -41,7 +41,7 @@ const config = {
   semantics: [
     {
       where: where(),
-      match: ({context}) => context.marker == 'mentions' && context.evaluate && context.args?.context?.ordinal,
+      match: ({context}) => context.marker == 'mentions' && context.args?.context?.ordinal,
       apply: async ({callId, _continue, toList, context, kms, e, log, toArray, retry}) => {
         // const ordinals = toArray(context.args?.context?.ordinal)
         const lastNotFirst = context.args?.context?.ordinal.value < 0